Back to index

php5  5.3.10
Public Member Functions | Static Public Member Functions | Protected Attributes
PharCommand Class Reference

PharCommand class. More...

Inheritance diagram for PharCommand:
Inheritance graph
[legend]
Collaboration diagram for PharCommand:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 cli_get_SP2 ($l1, $arg_inf)
 cli_get_SP3 ($l1, $l2, $arg_inf)
 Cli Get SP3.
 phar_check_hash ($hash, $privkey)
 Check whether hash method is valid.
 phar_set_stub_begin (Phar $phar, $stub, $loader=NULL, $hashbang=NULL)
 Set the stub.
 phar_set_stub_end (Phar $phar, $stub, $loader=NULL)
 Set stub end.
 cli_cmd_run_pack ()
 Pack a new Phar.
 phar_dir_echo ($pn, $f)
 Echo directory.
 phar_dir_operation (RecursiveIteratorIterator $dir, $func, array $args=array())
 Directory operations.
 cli_cmd_run_list ()
 Cli Command Run List.
 cli_cmd_run_tree ()
 Cli Command Run Tree.
 cli_cmd_run_extract ()
 Run Extract.
 phar_dir_extract ($pn, $f, $args)
 Extract to a directory.
 cli_cmd_run_delete ()
 Deleting execution.
 cli_cmd_run_add ()
 Add a file.
 cli_cmd_inf_stub_set ()
 Set the stup of a phar file.
 cli_cmd_arg_stub_set ()
 Set the argument stub.
 cli_cmd_run_stub_set ()
 Cli Command run stub set.
 cli_cmd_inf_stub_get ()
 Get the command stub infos.
 cli_cmd_arg_stub_get ()
 Get the argument stub.
 cli_cmd_run_stub_get ($args)
 Cli Command Run Stub.
 cli_cmd_inf_compress ()
 Cli Command Inf Compress.
 cli_cmd_arg_compress ()
 Cli Command Arg Compress.
 cli_cmd_run_compress ()
 Cli Command Run Compress.
 cli_cmd_inf_sign ()
 Cli Command Info Signature.
 cli_cmd_arg_sign ()
 Cli Command Argument Sign.
 cli_cmd_run_sign ()
 Cli Command Run Signature.
 cli_cmd_inf_meta_set ()
 Cli Command Inf Meta Set.
 cli_cmd_arg_meta_set ()
 Cli Command Argument Meta Set.
 cli_cmd_run_meta_set ()
 Cli Command Run Metaset.
 cli_cmd_inf_meta_get ()
 Cli Command Inf Metaget.
 cli_cmd_arg_meta_get ()
 Cli Command arg metaget.
 cli_cmd_run_meta_get ()
 Cli Command Run Metaget.
 cli_cmd_inf_meta_del ()
 Cli Command Inf Metadel.
 cli_cmd_arg_meta_del ()
 CliC ommand Arg Metadelete.
 cli_cmd_run_meta_del ()
 Cli Command Run MetaDel.
 cli_cmd_inf_info ()
 CLi Command Inf Info.
 cli_cmd_arg_info ()
 Cli Command Arg Infos.
 cli_cmd_run_info ()
 Cli Command Run Info.
 cli_cmd_inf_version ()
 CLi Command Inf Version.
 cli_cmd_arg_version ()
 Cli Command Arg Version.
 cli_cmd_run_version ()
 Cli Command Run Info.
 checkArgTyp ($arg, $i, $argc, $argv)
 cli_cmd_arg_help ()
 cli_cmd_run_help ()
 cli_cmd_run_help_list ()

Static Public Member Functions

static phar_args ($which, $phartype)
 Phar arguments.
static strEndsWith ($haystack, $needle)
 String Ends With.
static cli_arg_typ_loader ($arg, $cfg, $key)
 Argument type loader.
static cli_arg_typ_pharnew ($arg, $cfg, $key)
 Argument type new phar.
static cli_arg_typ_pharfile ($arg, $cfg, $key)
 Argument type existing Phar file.
static cli_arg_typ_pharurl ($arg, $cfg, $key)
 Argument type Phar url-like.
static cli_arg_typ_phar ($arg, $cfg, $key)
 Cli argument type phar.
static cli_arg_typ_entry ($arg, $cfg, $key)
 Argument type Entry name.
static cli_arg_typ_compalg ($arg, $cfg, $key)
 Argument type compression algorithm.
static cli_arg_typ_privkey ($arg, $cfg, $key)
 Argument type private key (for OpenSSL signing)
static cli_cmd_inf_pack ()
 Information pack.
static cli_cmd_arg_pack ()
 Pack a new phar infos.
static phar_add (Phar $phar, $level, $input, $regex, $invregex, SplFileInfo $stub=NULL, $compress=NULL, $noloader=false)
 Add files to a phar archive.
static phar_add_file (Phar $phar, $level, $entry, $file, $compress, $noloader=false)
 Add a phar file.
static cli_cmd_inf_list ()
 Cli Command Info List.
static cli_cmd_arg_list ()
 Cli Command Argument List.
static cli_cmd_inf_tree ()
 Cli Command Inf Tree.
static cli_cmd_arg_tree ()
 Cli Command Argument Tree.
static cli_cmd_inf_extract ()
 Cli Command Inf Extract.
static cli_cmd_arg_extract ()
 Cli Command Arguments Extract.
static cli_cmd_inf_delete ()
 Delete an entry from a phar information.
static cli_cmd_arg_delete ()
 The cli command argument for deleting.
static cli_cmd_inf_add ()
 Client comment add file information.
static cli_cmd_arg_add ()
 Add a file arguments.
static notice ($msg)
static error ($msg, $exit_code=1)
static getSubFuncs (CLICommand $cmdclass, $prefix, array $subs)
static getCommands (CLICommand $cmdclass)
static getArgTyps (CLICommand $cmdclass)
static cli_arg_typ_bool ($arg, $cfg, $key)
static cli_arg_typ_int ($arg, $cfg, $key)
static cli_arg_typ_regex ($arg, $cfg, $key)
static cli_arg_typ_select ($arg, $cfg, $key)
static cli_arg_typ_dir ($arg, $cfg, $key)
static cli_arg_typ_file ($arg)
static cli_arg_typ_filenew ($arg, $cfg, $key)
static cli_arg_typ_filecont ($arg, $cfg, $key)
static cli_cmd_inf_help ()
static cli_cmd_inf_help_list ()

Protected Attributes

 $argc
 $argv
 $cmds = array()
 $args = array()
 $typs = array()

Detailed Description

PharCommand class.

This class handles the handling of the phar commands. It will be used from command line/console in order to retrieve and execute phar functions.

Phar console command implementation

Author:
Marcus Boerger
Version:
1.0

Definition at line 25 of file pharcommand.inc.


Member Function Documentation

CLICommand::checkArgTyp ( arg,
i,
argc,
argv 
) [inherited]

Definition at line 101 of file clicommand.inc.

       {
              $typ = $this->args[$arg]['typ'];

              if (isset($this->typs[$typ]['typ'])) {
                     return call_user_func(array($this, $this->typs[$typ]['typ']), $argv[$i], $this->args[$arg], $arg);
              } else {
                     return $argv[$i];
              }
       }

Here is the caller graph for this function:

static CLICommand::cli_arg_typ_bool ( arg,
cfg,
key 
) [static, inherited]

Definition at line 146 of file clicommand.inc.

       {
              return (bool)$arg;
       }
static PharCommand::cli_arg_typ_compalg ( arg,
cfg,
key 
) [static]

Argument type compression algorithm.

Parameters:
string$argThe phar selection
string$cfgThe config option.
string$keyThe key information.
Returns:
string $arg The selected algorithm

Definition at line 371 of file pharcommand.inc.

       {
              $arg = self::cli_arg_typ_select($arg, $cfg, $key);

              switch($arg) {
                     case 'auto':
                            if (extension_loaded('zlib')) {
                                   $arg = 'gz';
                            } elseif (extension_loaded('bz2')) {
                                   $arg = 'bz2';
                            } else {
                                   $arg = '0';
                            }
                            break;
              }
              return $arg;
       }

Here is the call graph for this function:

static CLICommand::cli_arg_typ_dir ( arg,
cfg,
key 
) [static, inherited]

Definition at line 181 of file clicommand.inc.

       {
              $f = realpath($arg);

              if ($f===false || !file_exists($f) || !is_dir($f)) {
                     self::error("Requested path '$arg' does not exist.\n");
              }
              return $f;
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_entry ( arg,
cfg,
key 
) [static]

Argument type Entry name.

Parameters:
string$argThe argument (the entry)
Returns:
string $arg The entry itself.

Definition at line 356 of file pharcommand.inc.

       {
              // no further check atm, maybe check for no '/' at beginning
              return $arg;
       }
static CLICommand::cli_arg_typ_file ( arg) [static, inherited]

Definition at line 191 of file clicommand.inc.

       {
              $f = new SplFileInfo($arg);
              $f = $f->getRealPath();
              if ($f===false || !file_exists($f)) {
                     echo "Requested file '$arg' does not exist.\n";
                     exit(1);
              }
              return $f;
       }

Here is the caller graph for this function:

static CLICommand::cli_arg_typ_filecont ( arg,
cfg,
key 
) [static, inherited]

Definition at line 213 of file clicommand.inc.

       {
              return file_get_contents(self::cli_arg_typ_file($arg, $cfg, $key));
       }
static CLICommand::cli_arg_typ_filenew ( arg,
cfg,
key 
) [static, inherited]

Definition at line 202 of file clicommand.inc.

       {
              $d = dirname($arg);
              $f = realpath($d);

              if ($f === false) {
                     self::error("Path for file '$arg' does not exist.\n");
              }
              return $f . '/' . basename($arg);
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static CLICommand::cli_arg_typ_int ( arg,
cfg,
key 
) [static, inherited]

Definition at line 151 of file clicommand.inc.

       {
              if ((int)$arg != $arg) {
                     self::error("Argument to -$key must be an integer.\n");
              }

              return (int)$arg;
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_loader ( arg,
cfg,
key 
) [static]

Argument type loader.

Parameters:
string$argEither 'auto', 'optional' or an filename that contains class PHP_Archive
string$cfgConfiguration to pass to a new file
string$keyThe key
Returns:
string $arg The argument.

Definition at line 211 of file pharcommand.inc.

       {
              if (($arg == '0' || $arg == '1') && !file_exists($arg) && substr(PHP_OS, 0, 3) != 'WIN') {
                     $found = NULL;
                     $apiver = false;
                     $path = explode(PATH_SEPARATOR, $_ENV['PATH']);
                     $pear = false;
                     foreach ($path as $component) {
                            if (file_exists($component . DIRECTORY_SEPARATOR . 'pear')
                                   && is_executable($component . DIRECTORY_SEPARATOR . 'pear')) {
                                   $pear = true;
                                   break;
                            }
                     }
                     if ($pear) {
                            $apiver = `pear -q info PHP_Archive 2>/dev/null|grep 'API Version'`;
                            $apiver = trim(substr($apiver, strlen('API Version')));
                     }
                     if ($apiver) {
                            self::notice("PEAR package PHP_Archive: API Version: $apiver.\n");
                            $files  = explode("\n", `pear list-files PHP_Archive`);
                            $phpdir = `pear config-get php_dir 2>/dev/null`;
                            $phpdir = trim($phpdir);
                            self::notice("PEAR package PHP_Archive: $phpdir.\n");
                            if (is_dir($phpdir)) {
                                   foreach($files as $ent) {
                                          $matches = NULL;
                                          if (preg_match(",^php[ \t]+([^ \t].*[\\\\/]PHP[\\\\/]Archive\.php)$,", $ent, $matches)) {
                                                 $sub = $matches[1];
                                                 if (strpos($sub, $phpdir) !== 0) {
                                                        $found = NULL;
                                                        break;
                                                 }
                                                 $found = $sub;
                                                 break;
                                          }
                                   }
                            } else {
                                   self::notice("PEAR package PHP_Archive: corrupt or inaccessible base dir: $php_dir.\n");
                            }
                     }
                     if (isset($found)) {
                            self::notice("PEAR package PHP_Archive: $found.\n");
                     } else {
                            $msg = "PEAR package PHP_Archive not installed: generated phar will require PHP's phar extension be enabled.\n";
                            if ($arg == '0') {
                                   self::notice($msg);
                            } else {
                                   self::error($msg);
                            }
                     }
                     $arg = $found;
              }
              return self::cli_arg_typ_file($arg);
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_phar ( arg,
cfg,
key 
) [static]

Cli argument type phar.

Parameters:
string$argThe phar archive to use.
Returns:
object new Phar of the passed argument.

Definition at line 340 of file pharcommand.inc.

       {
              try {
                     return new Phar(self::cli_arg_typ_pharfile($arg, $cfg, $key));
              } catch(Exception $e) {
                     self::error("Exception while opening phar '$argv':\n" . $e->getMessage() . "\n");
              }
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_pharfile ( arg,
cfg,
key 
) [static]

Argument type existing Phar file.

Return filename of an existing Phar.

Parameters:
string$argThe file in the phar to open.
string$cfgThe configuration information
string$keyThe key information.
Returns:
string $pharfile The name of the loaded Phar file.
Note:
The Phar will be loaded

Definition at line 297 of file pharcommand.inc.

       {
              try {
                     $pharfile = self::cli_arg_typ_file($arg, $cfg, $key);

                     if (!Phar::loadPhar($pharfile)) {
                            self::error("Unable to open phar '$arg'\n");
                     }

                     return $pharfile;
              } catch(Exception $e) {
                     self::error("Exception while opening phar '$arg':\n" . $e->getMessage() . "\n");
              }
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static PharCommand::cli_arg_typ_pharnew ( arg,
cfg,
key 
) [static]

Argument type new phar.

Parameters:
string$argThe new phar component.
string$cfgConfiguration to pass to a new file
string$keyThe key
Returns:
string $arg The new argument file.

Definition at line 276 of file pharcommand.inc.

       {
              $arg = self::cli_arg_typ_filenew($arg, $cfg, $key);
              if (!Phar::isValidPharFilename($arg)) {
                     self::error("Phar files must have file extension '.phar', '.phar.php', '.phar.bz2' or '.phar.gz'.\n");
              }
              return $arg;
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_pharurl ( arg,
cfg,
key 
) [static]

Argument type Phar url-like.

Check the argument as cli_arg_Typ_phar and return its name prefixed with phar://

Ex: $arg = 'pharchive.phar/file.php'; cli_arg_typ_pharurl($arg)

Parameters:
string$argThe url-like phar archive to retrieve.
Returns:
string The phar file-archive.

Definition at line 328 of file pharcommand.inc.

       {
              return 'phar://' . self::cli_arg_typ_pharfile($arg, $cfg, $key);
       }

Here is the call graph for this function:

static PharCommand::cli_arg_typ_privkey ( arg,
cfg,
key 
) [static]

Argument type private key (for OpenSSL signing)

Parameters:
string$argThe phar selection
string$cfgThe config option.
string$keyThe key information.
Returns:
string $arg The private key.

Definition at line 398 of file pharcommand.inc.

       {
              $arg = self::cli_arg_typ_string($arg, $cfg, $key);

              $hash_avail = Phar::getSupportedSignatures();
              if ($arg && !in_array('OpenSSL', $hash_avail))
              {
                     self::error("Cannot specifiy private key without OpenSSL support.\n");
              }
              return $arg;
       }

Here is the call graph for this function:

static CLICommand::cli_arg_typ_regex ( arg,
cfg,
key 
) [static, inherited]

Definition at line 160 of file clicommand.inc.

       {
              if (strlen($arg)) {
                     if (strlen($arg) > 1 && $arg[0] == $arg[strlen($arg)-1] && strpos('/,', $arg) !== false) {
                            return $arg;
                     } else {
                            return '/' . $arg . '/';
                     }
              } else {
                     return NULL;
              }
       }
static CLICommand::cli_arg_typ_select ( arg,
cfg,
key 
) [static, inherited]

Definition at line 173 of file clicommand.inc.

       {
              if (!in_array($arg, array_keys($cfg['select']))) {
                     self::error("Parameter value '$arg' not one of '" . join("', '", array_keys($cfg['select'])) . "'.\n");
              }
              return $arg;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static PharCommand::cli_cmd_arg_add ( ) [static]

Add a file arguments.

Definition at line 977 of file pharcommand.inc.

       {
              $args = self::phar_args('acFilx', 'phar');
              $args[''] = array(
                     'type'     => 'any',
                     'val'      => NULL,
                     'required' => 1,
                     'inf'      => '         Any number of input files and directories. If -i is in use then ONLY files and matching thegiven regular expression are being packed. If -x is given then files matching that regular expression are NOT being packed.',
              );
              return $args;
       }

Here is the call graph for this function:

Cli Command Arg Compress.

Returns:
array The arguments for compress

Definition at line 1121 of file pharcommand.inc.

       {
              return self::phar_args('FCe', 'phar');
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_arg_delete ( ) [static]

The cli command argument for deleting.

Returns:
array informations about the arguments to use.

Definition at line 941 of file pharcommand.inc.

       {
              return self::phar_args('FE', 'phar');
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_arg_extract ( ) [static]

Cli Command Arguments Extract.

The arguments for the extract function.

Returns:
array The arguments for the extraction.

Definition at line 842 of file pharcommand.inc.

       {
              $args = self::phar_args('Fix', 'phar');

              $args[''] = array(
                     'type' => 'dir',
                     'val' => '.',
                     'inf' => '         Directory to extract to (defaults to \'.\').',
              );

              return $args;
       }

Here is the call graph for this function:

Definition at line 281 of file clicommand.inc.

       {
              return array('' => array('typ'=>'any','val'=>NULL,'inf'=>'Optional command to retrieve help for.'));
       }

Cli Command Arg Infos.

Returns:
array The arguments for info command.

Definition at line 1445 of file pharcommand.inc.

       {
              return self::phar_args('Fk', 'phar');
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_arg_list ( ) [static]

Cli Command Argument List.

Returns:
arguments list

Definition at line 759 of file pharcommand.inc.

       {
              return self::phar_args('Fix', 'pharurl');
       }

Here is the call graph for this function:

CliC ommand Arg Metadelete.

Returns:
array The arguments for metadel

Definition at line 1371 of file pharcommand.inc.

       {
              return self::phar_args('Fek', 'phar');
       }

Here is the call graph for this function:

Cli Command arg metaget.

Returns:
array The arguments for meta get.

Definition at line 1303 of file pharcommand.inc.

       {
              return self::phar_args('Fek', 'phar');
       }

Here is the call graph for this function:

Cli Command Argument Meta Set.

Returns:
array The arguments for meta set

Definition at line 1226 of file pharcommand.inc.

       {
              return self::phar_args('FekM', 'phar');
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_arg_pack ( ) [static]

Pack a new phar infos.

Returns:
array $args The arguments for a new Phar archive.

Definition at line 456 of file pharcommand.inc.

       {
              $args = self::phar_args('abcFhilpsxy', 'pharnew');

              $args[''] = array(
                     'typ'     => 'any',
                     'val'      => NULL,
                     'required' => 1,
                     'inf'      => '         Any number of input files and directories. If -i is in use then ONLY files and matching thegiven regular expression are being packed. If -x is given then files matching that regular expression are NOT being packed.',
              );

              return $args;
       }

Here is the call graph for this function:

Cli Command Argument Sign.

Returns:
array Arguments for Signature

Definition at line 1181 of file pharcommand.inc.

       {
              return self::phar_args('FHy', 'phar');
       }

Here is the call graph for this function:

Get the argument stub.

Returns:
array $args The arguments passed to the stub.

Definition at line 1078 of file pharcommand.inc.

       {
              $args = self::phar_args('Fs', 'phar');
              $args['s']['val'] = 'php://stdin';
              return $args;
       }

Here is the call graph for this function:

Set the argument stub.

Returns:
string arguments for a stub

Definition at line 1036 of file pharcommand.inc.

       {
              $args = self::phar_args('bFps', 'phar');
              $args['s']['val'] = 'php://stdin';
              return $args;
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_arg_tree ( ) [static]

Cli Command Argument Tree.

Returns:
string Arguments in URL format.

Definition at line 796 of file pharcommand.inc.

       {
              return self::phar_args('Fix', 'pharurl');
       }

Here is the call graph for this function:

Cli Command Arg Version.

Returns:
array The arguments for version command.

Definition at line 1553 of file pharcommand.inc.

       {
              return self::phar_args('', NULL);
       }

Here is the call graph for this function:

static PharCommand::cli_cmd_inf_add ( ) [static]

Client comment add file information.

Returns:
string The description of the feature

Definition at line 968 of file pharcommand.inc.

       {
              return "Add entries to a PHAR package.";
       }

Cli Command Inf Compress.

Cli Command compress informations

Returns:
string A description of the command.

Definition at line 1110 of file pharcommand.inc.

       {
              return "Compress or uncompress all files or a selected entry.";
       }
static PharCommand::cli_cmd_inf_delete ( ) [static]

Delete an entry from a phar information.

Returns:
string The information

Definition at line 930 of file pharcommand.inc.

       {
              return 'Delete entry from a PHAR archive';
       }
static PharCommand::cli_cmd_inf_extract ( ) [static]

Cli Command Inf Extract.

Returns:
string The description of the command extra to a directory.

Definition at line 829 of file pharcommand.inc.

       {
              return "Extract a PHAR package to a directory.";
       }
static CLICommand::cli_cmd_inf_help ( ) [static, inherited]

Definition at line 228 of file clicommand.inc.

       {
              return "This help or help for a selected command.";
       }
static CLICommand::cli_cmd_inf_help_list ( ) [static, inherited]

Definition at line 339 of file clicommand.inc.

       {
              return "Lists available commands.";
       }

CLi Command Inf Info.

Returns:
string A description about the info commands.

Definition at line 1433 of file pharcommand.inc.

       {
              return "Get information about a PHAR package.\n" .
                        "By using -k it is possible to return a single value.";
       }
static PharCommand::cli_cmd_inf_list ( ) [static]

Cli Command Info List.

Returns:
string What inf does

Definition at line 748 of file pharcommand.inc.

       {
              return "List contents of a PHAR archive.";
       }

Cli Command Inf Metadel.

Returns:
string A description of the metadel function

Definition at line 1357 of file pharcommand.inc.

       {
              return "Delete meta information of a PHAR entry or a PHAR package.\n" .
                        "If -k is given then the metadata is expected to be an array " .
                        "and the given index is being deleted.\n" .
                        "If something was deleted the return value is 0 otherwise it is 1.";
       }

Cli Command Inf Metaget.

Returns:
string A description of the metaget arguments

Definition at line 1287 of file pharcommand.inc.

       {
              return "Get meta information of a PHAR entry or a PHAR package in serialized from. " .
                        "If no output file is specified for meta data then stdout is being used.\n" .
                        "You can also specify a particular index using -k. In that case the metadata is " .
                        "expected to be an array and the value of the given index is returned using echo " .
                        "rather than using serialize. If that index does not exist or no meta data is " .
                        "present then the return value is 1.";
       }

Cli Command Inf Meta Set.

Returns:
string A description

Definition at line 1209 of file pharcommand.inc.

       {
              return "Set meta data of a PHAR entry or a PHAR package using serialized input. " .
                        "If no input file is specified for meta data then stdin is being used." .
                        "You can also specify a particular index using -k. In that case the metadata is " .
                        "expected to be an array and the value of the given index is being set. If " .
                        "the metadata is not present or empty a new array will be created. If the " .
                        "metadata is present and a flat value then the return value is 1. Also using -k " .
                        "the input is been taken directly rather then being serialized.";
       }
static PharCommand::cli_cmd_inf_pack ( ) [static]

Information pack.

Returns:
string A description about packing files into a Phar archive.

Definition at line 441 of file pharcommand.inc.

       {
              return "Pack files into a PHAR archive.\n" .
                        "When using -s <stub>, then the stub file is being " .
                        "excluded from the list of input files/dirs." .
                        "To create an archive that contains PEAR class PHP_Archive " .
                        "then point -p argument to PHP/Archive.php.\n";
       }

Cli Command Info Signature.

Returns:
string A description of the signature arguments.

Definition at line 1170 of file pharcommand.inc.

       {
              return "Set signature hash algorithm.";
       }

Get the command stub infos.

Returns:
string a description of the stub of a Phar file.

Definition at line 1066 of file pharcommand.inc.

       {
              return "Get the stub of a PHAR file. " .
                        "If no output file is specified as stub then stdout is being used.";
       }

Set the stup of a phar file.

Returns:
string The stub set description.

Definition at line 1024 of file pharcommand.inc.

       {
              return "Set the stub of a PHAR file. " .
                        "If no input file is specified as stub then stdin is being used.";
       }
static PharCommand::cli_cmd_inf_tree ( ) [static]

Cli Command Inf Tree.

Returns:
string The description of a directory tree for a Phar archive.

Definition at line 785 of file pharcommand.inc.

       {
              return "Get a directory tree for a PHAR archive.";
       }

CLi Command Inf Version.

Returns:
string A description about the info commands.

Definition at line 1542 of file pharcommand.inc.

       {
              return "Get information about the PHAR environment and the tool version.";
       }

Add a file.

Run the action of adding a file to a phar archive.

Definition at line 996 of file pharcommand.inc.

       {
              $compress= $this->args['c']['val'];
              $phar    = $this->args['f']['val'];
              $regex   = $this->args['i']['val'];
              $level   = $this->args['l']['val'];
              $invregex= $this->args['x']['val'];
              $input   = $this->args['']['val'];

              $phar->startBuffering();

              if (!is_array($input)) {
                     $this->phar_add($phar, $level, $input, $regex, $invregex, NULL, $compress);
              } else {
                     foreach($input as $i) {
                            $this->phar_add($phar, $level, $i, $regex, $invregex, NULL, $compress);
                     }
              }
              $phar->stopBuffering();
              exit(0);
       }

Here is the call graph for this function:

Cli Command Run Compress.

See also:
$this->args

Definition at line 1132 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $entry = $this->args['e']['val'];

              switch($this->args['c']['val']) {
                     case 'gz':
                     case 'gzip':
                            if (isset($entry)) {
                                   $phar[$entry]->compress(Phar::GZ);
                            } else {
                                   $phar->compressFiles(Phar::GZ);
                            }
                            break;
                     case 'bz2':
                     case 'bzip2':
                            if (isset($entry)) {
                                   $phar[$entry]->compress(Phar::BZ2);
                            } else {
                                   $phar->compressFiles(Phar::BZ2);
                            }
                            break;
                     default:
                            if (isset($entry)) {
                                   $phar[$entry]->decompress();
                            } else {
                                   $phar->decompressFiles();
                            }
                            break;
              }
       }

Deleting execution.

Execute the deleting of the file from the phar archive.

Definition at line 952 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $entry = $this->args['e']['val'];

              $phar->startBuffering();
              unset($phar[$entry]);
              $phar->stopBuffering();
       }

Run Extract.

Run the extraction of a phar Archive.

See also:
$this->phar_dir_operation

Definition at line 863 of file pharcommand.inc.

       {
              $dir = $this->args['']['val'];

              if (is_array($dir)) {
                     if (count($dir) != 1) {
                            self::error("Only one target directory allowed.\n");
                     } else {
                            $dir = $dir[0];
                     }
              }

              $phar = $this->args['f']['val'];
              $base = $phar->getPathname();
              $bend = strpos($base, '.phar');
              $bend = strpos($base, '/', $bend);
              $base = substr($base, 0, $bend + 1);
              $blen = strlen($base);

              $this->phar_dir_operation(
                     new RecursiveIteratorIterator($phar),
                     array($this, 'phar_dir_extract'),
                     array($blen, $dir)
              );
       }

Here is the call graph for this function:

Definition at line 286 of file clicommand.inc.

       {
              $argv  = $this->argv;
              $which = $this->args['']['val'];
              if (isset($which)) {
                     if (count($which) != 1) {
                            self::error("More than one command given.\n");
                     }

                     $which = $which[0];
                     if (!array_key_exists($which, $this->cmds)) {
                            if (strtolower($which) == 'commands') {
                                   self::cli_cmd_run_help_list();
                                   exit(0);
                            }
                            self::error("Unknown command, cannot retrieve help.\n");
                     }

                     $l = strlen($which);
                     $cmds = array($which => $this->cmds[$which]);
              } else {
                     echo "\n$argv[0] <command> [options]\n\n";
                     $l = 0;
                     ksort($this->cmds);
                     foreach($this->cmds as $name => $funcs) {
                            $l = max($l, strlen($name));
                     }
                     $inf = "Commands:";
                     $lst = "";
                     $ind = strlen($inf) + 1;
                     foreach($this->cmds as $name => $funcs) {
                            $lst .= ' ' . $name;
                     }
                     echo $this->cli_wordwrap($inf.$lst, $ind, str_repeat(' ', $ind)) . "\n\n";
                     $cmds = $this->cmds;
              }
              $sp = str_repeat(' ', $l + 2);
              foreach($cmds as $name => $funcs) {
                     $inf = $name . substr($sp, strlen($name));
                     if (isset($funcs['inf'])) {
                            $inf .= $this->cli_wordwrap(call_user_func(array($this, $funcs['inf'])), $l, $sp) . "\n";
                            if (isset($funcs['arg'])) {
                                   $inf .= "\n";
                                   $inf .= $this->cli_help_get_args(array($this, $funcs['arg']), $l, $sp, true);
                                   $inf .= "\n";
                                   $inf .= $this->cli_help_get_args(array($this, $funcs['arg']), $l, $sp, false);
                            }
                     }
                     echo "$inf\n\n";
              }
              exit(0);
       }

Here is the call graph for this function:

Definition at line 344 of file clicommand.inc.

       {
              ksort($this->cmds);
              echo join(' ', array_keys($this->cmds)) . "\n";
       }

Here is the caller graph for this function:

Cli Command Run Info.

Parameters:
args$args

Definition at line 1456 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $index = $this->args['k']['val'];

              $hash  = $phar->getSignature();
              $infos = array();

              if ($phar->getAlias()) {
                     $infos['Alias'] = $phar->getAlias();
              }

              if (!$hash) {
                     $infos['Hash-type'] = 'NONE';
              } else {
                     $infos['Hash-type'] = $hash['hash_type'];
                     $infos['Hash'] = $hash['hash'];
              }

              $csize   = 0;
              $usize   = 0;
              $count   = 0;
              $ccount  = 0;
              $ucount  = 0;
              $mcount  = 0;
              $compalg = array('GZ'=>0, 'BZ2'=>0);

              foreach(new RecursiveIteratorIterator($phar) as $ent) {
                     $count++;
                     if ($ent->isCompressed()) {
                            $ccount++;
                            $csize += $ent->getCompressedSize();
                            if ($ent->isCompressed(Phar::GZ)) {
                                   $compalg['GZ']++;
                            } elseif ($ent->isCompressed(Phar::BZ2)) {
                                   $compalg['BZ2']++;
                            }
                     } else {
                            $ucount++;
                            $csize += $ent->getSize();
                     }

                     $usize += $ent->getSize();

                     if ($ent->hasMetadata()) {
                            $mcount++;
                     }
              }

              $infos['Entries']            = $count;
              $infos['Uncompressed-files'] = $ucount;
              $infos['Compressed-files']   = $ccount;
              $infos['Compressed-gz']      = $compalg['GZ'];
              $infos['Compressed-bz2']     = $compalg['BZ2'];
              $infos['Uncompressed-size']  = $usize;
              $infos['Compressed-size']    = $csize;
              $infos['Compression-ratio']  = sprintf('%.3g%%', $usize ? ($csize * 100) / $usize : 100);
              $infos['Metadata-global']    = $phar->hasMetadata() * 1;
              $infos['Metadata-files']     = $mcount;
              $infos['Stub-size']          = strlen($phar->getStub());

              if (isset($index)) {
                     if (!isset($infos[$index])) {
                            self::error("Requested value does not exist.\n");
                     }

                     echo $infos[$index];
                     exit(0);
              }

              $l = 0;
              foreach($infos as $which => $val) {
                     $l = max(strlen($which), $l);
              }

              foreach($infos as $which => $val) {
                     echo $which . ':' . str_repeat(' ', $l + 1 - strlen($which)) . $val . "\n";
              }
       }

Here is the call graph for this function:

Cli Command Run List.

See also:
$this->phar_dir_operation

Definition at line 770 of file pharcommand.inc.

       {
              $this->phar_dir_operation(
                     new DirectoryTreeIterator(
                            $this->args['f']['val']),
                            array($this, 'phar_dir_echo')
                     );
       }

Here is the call graph for this function:

Cli Command Run MetaDel.

See also:
$phar[$x]->delMetadata()
$phar->delMetadata()

Definition at line 1383 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $entry = $this->args['e']['val'];
              $index = $this->args['k']['val'];

              if (isset($entry)) {
                     if (isset($index)) {
                            if (!$phar[$entry]->hasMetadata()) {
                                   exit(1);
                            }
                            $meta = $phar[$entry]->getMetadata();

                            // @todo add error message here.
                            if (!is_array($meta)) {
                                   exit(1);
                            }

                            unset($meta[$index]);
                            $phar[$entry]->setMetadata($meta);
                     } else {
                            exit($phar[$entry]->delMetadata() ? 0 : 1);
                     }
              } else {
                     if (isset($index)) {
                            if (!$phar->hasMetadata()) {
                                   exit(1);
                            }

                            $meta = $phar->getMetadata();

                            // @todo Add error message
                            if (!is_array($meta)) {
                                   exit(1);
                            }

                            unset($meta[$index]);
                            $phar->setMetadata($meta);
                     } else {
                            exit($phar->delMetadata() ? 0 : 1);
                     }
              }
       }

Cli Command Run Metaget.

See also:
$this->args
$phar[$x]->hasMetadata()
$phar->getMetadata()

Definition at line 1316 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $entry = $this->args['e']['val'];
              $index = $this->args['k']['val'];

              if (isset($entry)) {
                     if (!$phar[$entry]->hasMetadata()) {
                            echo "No Metadata\n";
                            exit(1);
                     }
                     echo serialize($phar[$entry]->getMetadata());
              } else {
                     if (!$phar->hasMetadata()) {
                            echo "No Metadata\n";
                            exit(1);
                     }
                     $meta = $phar->getMetadata();
              }

              if (isset($index)) {
                     if (isset($index)) {
                            if (isset($meta[$index])) {
                                   echo $meta[$index];
                                   exit(0);
                            } else {
                                   echo "No Metadata\n";
                                   exit(1);
                            }
                     } else {
                            echo serialize($meta);
                     }
              }
       }

Cli Command Run Metaset.

See also:
$phar->startBuffering
$phar->setMetadata
$phar->stopBuffering

Definition at line 1239 of file pharcommand.inc.

       {
              $phar  = $this->args['f']['val'];
              $entry = $this->args['e']['val'];
              $index = $this->args['k']['val'];
              $meta  = $this->args['m']['val'];

              $phar->startBuffering();

              if (isset($index)) {
                     if (isset($entry)) {
                            if ($phar[$entry]->hasMetadata()) {
                                   $old = $phar[$entry]->getMetadata();
                            } else {
                                   $old = array();
                            }
                     } else {
                            if ($phar->hasMetadata()) {
                                   $old = $phar->getMetadata();
                            } else {
                                   $old = array();
                            }
                     }

                     if (!is_array($old)) {
                            self::error('Metadata is a flat value while an index operation was issued.');
                     }

                     $old[$index] = $meta;
                     $meta = $old;
              } else {
                     $meta = unserialize($meta);
              }

              if (isset($entry)) {
                     $phar[$entry]->setMetadata($meta);
              } else {
                     $phar->setMetadata($meta);
              }
              $phar->stopBuffering();
       }

Here is the call graph for this function:

Pack a new Phar.

This function will try to pack a new Phar archive.

See also:
Exit to make sure that we are done.

Definition at line 552 of file pharcommand.inc.

       {
              if (ini_get('phar.readonly')) {
                     self::error("Creating phar files is disabled by ini setting 'phar.readonly'.\n");
              }

              if (!Phar::canWrite()) {
                     self::error("Creating phar files is disabled, Phar::canWrite() returned false.\n");
              }

              $alias    = $this->args['a']['val'];
              $hashbang = $this->args['b']['val'];
              $archive  = $this->args['f']['val'];
              $hash     = $this->args['h']['val'];
              $privkey  = $this->args['y']['val'];
              $regex    = $this->args['i']['val'];
              $level    = $this->args['l']['val'];
              $loader   = $this->args['p']['val'];
              $stub     = $this->args['s']['val'];
              $invregex = $this->args['x']['val'];
              $input    = $this->args['']['val'];

              $hash = self::phar_check_hash($hash, $privkey);

              $phar  = new Phar($archive, 0, $alias);

              $phar->startBuffering();

              $stub = $this->phar_set_stub_begin($phar, $stub, $loader, $hashbang);

              if (!is_array($input)) {
                     $this->phar_add($phar, $level, $input, $regex, $invregex, $stub, NULL, isset($loader));
              } else {
                     foreach($input as $i) {
                            $this->phar_add($phar, $level, $i, $regex, $invregex, $stub, NULL, isset($loader));
                     }
              }

              $this->phar_set_stub_end($phar, $stub, $loader);

              switch($this->args['c']['val']) {
                     case 'gz':
                     case 'gzip':
                            $phar->compressFiles(Phar::GZ);
                            break;
                     case 'bz2':
                     case 'bzip2':
                            $phar->compressFiles(Phar::BZ2);
                            break;
                     default:
                            $phar->decompressFiles();
                            break;
              }

              if ($hash) {
                     $phar->setSignatureAlgorithm($hash, $privkey);
              }

              $phar->stopBuffering();
              exit(0);
       }

Here is the call graph for this function:

Cli Command Run Signature.

See also:
$phar->setSignaturealgorithm

Definition at line 1192 of file pharcommand.inc.

       {
              $phar     = $this->args['f']['val'];
              $hash     = $this->args['h']['val'];
              $privkey  = $this->args['y']['val'];

              $hash = self::phar_check_hash($hash, $privkey);

              $phar->setSignatureAlgorithm($hash, $privkey);
       }

Here is the call graph for this function:

Cli Command Run Stub.

Get arguments and store them into a stub.

Parameters:
arguments$args
See also:
$this->args

Definition at line 1094 of file pharcommand.inc.

       {
              $phar = $this->args['f']['val'];
              $stub = $this->args['s']['val'];

              file_put_contents($stub, $phar->getStub());
       }

Cli Command run stub set.

See also:
$phar->setStub()

Definition at line 1049 of file pharcommand.inc.

       {
              $hashbang = $this->args['b']['val'];
              $phar     = $this->args['f']['val'];
              $stub     = $this->args['s']['val'];
              $loader   = $this->args['p']['val'];

              $this->phar_set_stub_begin($phar, $stub, $loader, $hashbang);
              $this->phar_set_stub_end($phar, $stub, $loader);
       }

Here is the call graph for this function:

Cli Command Run Tree.

Set the phar_dir_operation with a directorygraphiterator.

See also:
DirectoryGraphIterator
$this->phar_dir_operation

Definition at line 811 of file pharcommand.inc.

       {
              $a = $this->phar_dir_operation(
                     new DirectoryGraphIterator(
                            $this->args['f']['val']),
                            array($this, 'phar_dir_echo')
                     );
              if (!$a) {
                     echo "|-<root directory>\n";
              }
       }

Here is the call graph for this function:

Cli Command Run Info.

Parameters:
args$args

Definition at line 1564 of file pharcommand.inc.

       {
              $use_ext = extension_loaded('phar');
              $version = array(
                     'PHP Version' => phpversion(),
                     'phar.phar version' => '$Revision: 282735 $',
                     'Phar EXT version' => $use_ext ? phpversion('phar') : 'Not available',
                     'Phar API version' => Phar::apiVersion(),
                     'Phar-based phar archives' => true,
                     'Tar-based phar archives' => $use_ext,
                     'ZIP-based phar archives' => $use_ext,
                     'gzip compression' => extension_loaded('zlib'),
                     'bzip2 compression' => extension_loaded('bz2'),
                     'supported signatures' => $use_ext ? join(', ', Phar::getSupportedSignatures()) : '',
                     );
              $klen = 0;
              foreach($version as $k => $v)
              {
                     $klen = max($klen, strlen($k));
              }
              ++$klen;
              foreach($version as $k => $v) {
                     if (is_bool($v)) {
                            $v = $v ? 'enabled' : 'disabled';
                     }
                     printf("%-${klen}s  %s\n", $k.':', $v);
              }
       }
PharCommand::cli_get_SP2 ( l1,
arg_inf 
)

Reimplemented from CLICommand.

Definition at line 28 of file pharcommand.inc.

       {
              return str_repeat(' ', $l1 + 2 + 4 + 9);
       }
PharCommand::cli_get_SP3 ( l1,
l2,
arg_inf 
)

Cli Get SP3.

Parameters:
string$l1Eleven
string$l2Twelve
string$arg_inf
Returns:
string The repeated string.

Reimplemented from CLICommand.

Definition at line 42 of file pharcommand.inc.

       {
              return str_repeat(' ', $l1 + 2 + 4 + 9 + 2 + $l2 + 2);
       }
static CLICommand::error ( msg,
exit_code = 1 
) [static, inherited]

Definition at line 95 of file clicommand.inc.

       {
              self::notice($msg);
              exit($exit_code);
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static CLICommand::getArgTyps ( CLICommand cmdclass) [static, inherited]

Definition at line 141 of file clicommand.inc.

       {
              return self::getSubFuncs($cmdclass, 'cli_arg_', array('typ'));
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static CLICommand::getCommands ( CLICommand cmdclass) [static, inherited]

Definition at line 136 of file clicommand.inc.

       {
              return self::getSubFuncs($cmdclass, 'cli_cmd_', array('arg','inf','run'));
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static CLICommand::getSubFuncs ( CLICommand cmdclass,
prefix,
array $  subs 
) [static, inherited]

Definition at line 112 of file clicommand.inc.

       {
              $a = array();
              $r = new ReflectionClass($cmdclass);
              $l = strlen($prefix);

              foreach($r->getMethods() as $m) {
                     if (substr($m->name, 0, $l) == $prefix) {
                            foreach($subs as $sub) {
                                   $what = substr($m->name, $l+strlen($sub)+1);
                                   $func = $prefix . $sub . '_' . $what;
                                   $what = str_replace('_', '-', $what);
                                   if ($r->hasMethod($func)) {
                                          if (!isset($a[$what])) {
                                                 $a[$what] = array();
                                          }
                                          $a[$what][$sub] = /*$m->class . '::' .*/ $func;
                                   }
                            }
                     }
              }
              return $a;
       }

Here is the caller graph for this function:

static CLICommand::notice ( msg) [static, inherited]

Definition at line 90 of file clicommand.inc.

       {
              fprintf(STDERR, $msg);
       }

Here is the caller graph for this function:

static PharCommand::phar_add ( Phar phar,
level,
input,
regex,
invregex,
SplFileInfo stub = NULL,
compress = NULL,
noloader = false 
) [static]

Add files to a phar archive.

This function will take a directory and iterate through it and get the files to insert into the Phar archive.

Parameters:
Phar$pharThe phar object.
string$inputThe input directory
string$regexThe regex used in RegexIterator.
string$invregexThe InvertedRegexIterator expression.
SplFileInfo$stubStub file object
mixed$compressCompression algorithm or NULL
boolean$noloaderWhether to prevent adding the loader

Definition at line 629 of file pharcommand.inc.

       {
              if ($input && is_file($input) && !is_dir($input)) {
                     return self::phar_add_file($phar, $level, $input, $input, $compress);
              }
              $dir   = new RecursiveDirectoryIterator($input);
              $dir   = new RecursiveIteratorIterator($dir);

              if (isset($regex)) {
                     $dir = new RegexIterator($dir, $regex);
              }

              if (isset($invregex)) {
                     $dir = new InvertedRegexIterator($dir, $invregex);
              }

              try {
                     foreach($dir as $file) {
                            if ((empty($stub) || $file->getRealPath() != $stub->getRealPath()) && !is_dir($file)) {
                                   self::phar_add_file($phar, $level, $dir->getSubPathName(), $file, $compress, $noloader);
                            }
                     }
              } catch(Excpetion $e) {
                     self::error("Unable to complete operation on file '$file'\n" . $e->getMessage() . "\n");
              }
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static PharCommand::phar_add_file ( Phar phar,
level,
entry,
file,
compress,
noloader = false 
) [static]

Add a phar file.

This function adds a file to a phar archive.

Parameters:
Phar$pharThe phar object
string$levelThe level of the file.
string$entryThe entry point
string$fileThe file to add to the archive
string$compressThe compression scheme for the file.
boolean$noloaderWhether to prevent adding the loader

Definition at line 669 of file pharcommand.inc.

       {
              $entry = str_replace('//', '/', $entry);
              while($level-- > 0 && ($p = strpos($entry, '/')) !== false) {
                     $entry = substr($entry, $p+1);
              }

       if ($noloader && $entry == 'phar.inc') {
              return;
       }

              echo "$entry\n";

              $phar[$entry] = file_get_contents($file);
              switch($compress) {
                     case 'gz':
                     case 'gzip':
                            $phar[$entry]->compress(Phar::GZ);
                            break;
                     case 'bz2':
                     case 'bzip2':
                            $phar[$entry]->compress(Phar::BZ2);
                            break;
                     case '0':
                            $phar[$entry]->decompress();
                            break;
                     default:
                            break;
              }
       }

Here is the caller graph for this function:

static PharCommand::phar_args ( which,
phartype 
) [static]

Phar arguments.

This function contains all the phar commands

Parameters:
string$whichWhich argument is chosen.
string$phartypeThe type of phar, specific file to work on
Returns:
unknown

Definition at line 57 of file pharcommand.inc.

       {
              $phar_args = array(
                     'a' => array(
                            'typ' => 'alias',
                            'val' => NULL,
                            'inf' => '<alias>  Provide an alias name for the phar file.'
                     ),
                     'b' => array(
                            'typ' => 'any',
                            'val' => NULL,
                            'inf' => '<bang>   Hash-bang line to start the archive (e.g. #!/usr/bin/php). The hash '
                                           .'         mark itself \'#!\' and the newline character are optional.'
                     ),
                     'c' => array(
                            'typ' => 'compalg',
                            'val' => NULL,
                            'inf' => '<algo>   Compression algorithm.',
                            'select' => array(
                                   '0'    => 'No compression',
                                   'none' => 'No compression',
                                   'auto' => 'Automatically select compression algorithm'
                            )
                     ),
                     'e' => array(
                            'typ' => 'entry',
                            'val' => NULL,
                            'inf' => '<entry>  Name of entry to work on (must include PHAR internal directory name if any).'
                     ),
                     'f' => array(
                            'typ' => $phartype,
                            'val' => NULL,
                            'inf' => '<file>   Specifies the phar file to work on.'
                     ),
                     'h' => array(
                            'typ' => 'select',
                            'val' => NULL,
                            'inf' => '<method> Selects the hash algorithmn.',
                            'select' => array('md5' => 'MD5','sha1' => 'SHA1')
                     ),
                     'i' => array(
                            'typ' => 'regex',
                            'val' => NULL,
                            'inf' => '<regex>  Specifies a regular expression for input files.'
                     ),
                     'k' => array(
                            'typ' => 'any',
                            'val' => NULL,
                            'inf' => '<index>  Subscription index to work on.',
                     ),
                     'l' => array(
                            'typ' => 'int',
                            'val' => 0,
                            'inf' => '<level>  Number of preceeding subdirectories to strip from file entries',
                     ),
                     'm' => array(
                            'typ' => 'any',
                            'val' => NULL,
                            'inf' => '<meta>   Meta data to store with entry (serialized php data).'
                     ),
                     'p' => array(
                            'typ' => 'loader',
                            'val' => NULL,
                            'inf' => '<loader> Location of PHP_Archive class file (pear list-files PHP_Archive).'
                                           .'You can use \'0\' or \'1\' to locate it automatically using the mentioned '
                                           .'pear command. When using \'0\' the command does not error out when the '
                                           .'class file cannot be located. This switch also adds some code around the '
                                           .'stub so that class PHP_Archive gets registered as phar:// stream wrapper '
                                           .'if necessary. And finally this switch will add the file phar.inc from '
                                           .'this package and load it to ensure class Phar is present.'
                                           ,
                     ),
                     's' => array(
                            'typ' => 'file',
                            'val' => NULL,
                            'inf' => '<stub>   Select the stub file.'
                     ),
                     'x' => array(
                            'typ' => 'regex',
                            'val' => NULL,
                            'inf' => '<regex>  Regular expression for input files to exclude.'
                     ),
                     'y' => array(
                            'typ' => 'privkey',
                            'val' => NULL,
                            'inf' => '<key>    Private key for OpenSSL signing.',
                     ),
              );

              if (extension_loaded('zlib')) {
                     $phar_args['c']['select']['gz']    = 'GZip compression';
                     $phar_args['c']['select']['gzip']  = 'GZip compression';
              }

              if (extension_loaded('bz2')) {
                     $phar_args['c']['select']['bz2']   = 'BZip2 compression';
                     $phar_args['c']['select']['bzip2'] = 'BZip2 compression';
              }

              $hash_avail = Phar::getSupportedSignatures();
              $hash_optional = array('SHA-256' => 'SHA256',
                                                    'SHA-512' => 'SHA512',
                                                    'OpenSSL' => 'OpenSSL');
              if (!in_array('OpenSSL', $hash_avail)) {
                     unset($phar_args['y']);
              }

              foreach($hash_optional as $key => $name) {
                     if (in_array($key, $hash_avail)) {
                            $phar_args['h']['select'][strtolower($name)] = $name;
                     }
              }

              $args = array();

              foreach($phar_args as $lkey => $cfg) {
                     $ukey     = strtoupper($lkey);
                     $required = strpos($which, $ukey) !== false;
                     $optional = strpos($which, $lkey) !== false;

                     if ($required || $optional) {
                            $args[$lkey] = $cfg;
                            $args[$lkey]['required'] = $required;
                     }
              }
              return $args;
       }

Here is the caller graph for this function:

PharCommand::phar_check_hash ( hash,
privkey 
)

Check whether hash method is valid.

Returns:
Hash constant to be used.

Definition at line 416 of file pharcommand.inc.

       {
              switch($hash) {
                     case 'md5':
                            return Phar::MD5;
                     case 'sha1':
                            return Phar::SHA1;
                     case 'sha256':
                            return Phar::SHA256;
                     case 'sha512':
                            return Phar::SHA512;
                     case 'openssl':
                            if (!$privkey) {
                                   self::error("Cannot use OpenSSL signing without key.\n");
                            }
                            return Phar::OPENSSL;
              }
       }

Here is the call graph for this function:

Here is the caller graph for this function:

PharCommand::phar_dir_echo ( pn,
f 
)

Echo directory.

Parameters:
string$pn
unknown_type$f

Definition at line 707 of file pharcommand.inc.

       {
              echo "$f\n";
       }
PharCommand::phar_dir_extract ( pn,
f,
args 
)

Extract to a directory.

This function will extract the content of a Phar to a directory and create new files and directories depending on the permissions on that folder.

Parameters:
string$pn
string$fThe file name
array$argsThe directory and Blen informations

Definition at line 901 of file pharcommand.inc.

       {
              $blen   = $args[0];
              $dir    = $args[1];
              $sub    = substr($pn, $blen);
              $target = $dir . '/' . $sub;

              if (!file_exists(dirname($target))) {
                     @mkdir(dirname($target), 0777, true);
              }
              if (!file_exists(dirname($target))) {
                     self::error("Operation could not be completed\n");
              }

              echo "$sub";

              if (!@copy($f, $target)) {
                     echo " ...error\n";
              } else {
                     echo " ...ok\n";
              }
       }

Here is the call graph for this function:

PharCommand::phar_dir_operation ( RecursiveIteratorIterator dir,
func,
array $  args = array() 
)

Directory operations.

Phar directory operations.

Parameters:
RecursiveIteratorIterator$dirThe recursiveIteratorIterator object.
string$funcFunction to call on the iterations
array$argsFunction arguments.

Definition at line 722 of file pharcommand.inc.

       {
              $regex   = $this->args['i']['val'];
              $invregex= $this->args['x']['val'];

              if (isset($regex)) {
                     $dir = new RegexIterator($dir, $regex);
              }

              if (isset($invregex)) {
                     $dir = new InvertedRegexIterator($dir, $invregex);
              }

              $any = false;
              foreach($dir as $pn => $f) {
                     $any = true;
                     call_user_func($func, $pn, $f, $args);
              }
              return $any;
       }

Here is the caller graph for this function:

PharCommand::phar_set_stub_begin ( Phar phar,
stub,
loader = NULL,
hashbang = NULL 
)

Set the stub.

Definition at line 474 of file pharcommand.inc.

       {
              if (isset($stub)) {
                     $c = file_get_contents($stub);

                     if (substr($c, 0, 2) == '#!') {
                            if (strpos($c, "\n") !== false) {
                                   if (!isset($hashbang)) {
                                          $hashbang = substr($c, 0, strpos($c, "\n") + 1);
                                   }
                                   $c = substr($c, strpos($c, "\n") + 1);
                            } else {
                                   if (!isset($hashbang)) {
                                          $hashbang = $c;
                                   }
                                   $c = NULL;
                            }
                     }

                     if (isset($hashbang)) {
                            if (substr($hashbang, 0, 2) != '#!') {
                                   $hashbang = '#!' . $hashbang;
                            }
                            if (substr($hashbang, -1) != "\n") {
                                   $hashbang .= "\n";
                            }
                     } else {
                            $hashbang = "";
                     }

                     if (isset($loader)) {
                            $s = "<?php if (!class_exists('PHP_Archive')) {\n?>";
                            if (is_file($loader)) {
                                   $s .= file_get_contents($loader);
                            }
                            $s .= "<?php\n";
                            $s .= "}\n";
                            $s .= "if (!in_array('phar', stream_get_wrappers())) {\n";
                            $s .= "\tstream_wrapper_register('phar', 'PHP_Archive');\n";
                            $s .= "}\n";
                            $s .= "if (!class_exists('Phar',0)) {\n";
                            $s .= "\tinclude 'phar://'.__FILE__.'/phar.inc';\n";
                            $s .= "}\n";
                            $s .= '?>';
                            $s .= $c;

                            $phar->setStub($hashbang . $s);
                     } else {
                            $phar->setStub($hashbang . $c);
                     }
                     return new SplFileInfo($stub);
              }
              return NULL;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

PharCommand::phar_set_stub_end ( Phar phar,
stub,
loader = NULL 
)

Set stub end.

Definition at line 533 of file pharcommand.inc.

       {
              if (isset($stub) && isset($loader)) {
                     if (substr(__FILE__, -15) == 'pharcommand.inc') {
                            self::phar_add_file($phar, 0, 'phar.inc', 'phar://'.__FILE__.'/phar.inc', NULL);
                     } else {
                            self::phar_add_file($phar, 0, 'phar.inc', dirname(__FILE__).'/phar/phar.inc', NULL);
                     }
              }
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static PharCommand::strEndsWith ( haystack,
needle 
) [static]

String Ends With.

Whether a string ends with another needle.

Parameters:
string$haystackThe haystack
string$needleThe needle.
Returns:
mixed false if doesn't end with anything, the string substr'ed if the string ends with the needle.

Definition at line 196 of file pharcommand.inc.

       {
              return substr($haystack, -strlen($needle)) == $needle;
       }

Member Data Documentation

CLICommand::$argc [protected, inherited]

Definition at line 19 of file clicommand.inc.

CLICommand::$args = array() [protected, inherited]

Definition at line 22 of file clicommand.inc.

CLICommand::$argv [protected, inherited]

Definition at line 20 of file clicommand.inc.

CLICommand::$cmds = array() [protected, inherited]

Definition at line 21 of file clicommand.inc.

CLICommand::$typs = array() [protected, inherited]

Definition at line 23 of file clicommand.inc.


The documentation for this class was generated from the following file: