497 lines
14 KiB
PHP
Executable File
497 lines
14 KiB
PHP
Executable File
#!/usr/bin/env php
|
|
<?php
|
|
/*
|
|
* Empir
|
|
*
|
|
Copyright (c) 2010 Jeremy Perret <j.perret.27@gmail.com>
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
*/
|
|
|
|
//if colors make any damages on your terminal deactivate them by setting to false this option
|
|
define('ACTIVATE_COLORS', true);
|
|
|
|
//only run Empir automatically when this file is called directly from the command line
|
|
if (isset($argv[0])) {
|
|
if (version_compare(phpversion(), '5.3.0', '<')) {
|
|
echo "ERROR: Empir require php >= 5.3.0 (Your PHP version: ".phpversion().")\n";
|
|
exit(1);
|
|
}
|
|
|
|
$empir = new Empir($argv);
|
|
exit($empir->run());
|
|
}
|
|
|
|
/**
|
|
* Command line interface Helper.
|
|
*
|
|
* @package Empir
|
|
* @author Jeremy Perret <j.perret.27@gmail.com>
|
|
*/
|
|
class CLI_Interface
|
|
{
|
|
protected function execCommand()
|
|
{
|
|
if (isset($this->commands[$this->command])) {
|
|
$method = $this->commands[$this->command];
|
|
$rcode = $this->$method();
|
|
}else
|
|
$rcode = $this->error("Command <$this->command> doesn't exist. Try <help>");
|
|
|
|
return ($rcode == null) ? 0 : $rcode;
|
|
}
|
|
|
|
protected function gopt($no)
|
|
{
|
|
if(isset($this->options[$no]))
|
|
|
|
return $this->options[$no];
|
|
return null;
|
|
}
|
|
|
|
protected function glopt($opt)
|
|
{
|
|
foreach ($this->options as $option) {
|
|
if(strpos($option, "--$opt=") !== false)
|
|
|
|
return trim(end(explode('=', $option)), '"');
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected function reqopt($no, $name)
|
|
{
|
|
if($this->gopt($no) == null)
|
|
exit($this->error("Param $name is required. Try <help>"));
|
|
|
|
return $this->gopt($no);
|
|
}
|
|
|
|
protected function error($message = '', $errno = 1)
|
|
{
|
|
if($message != '')
|
|
echo Color::str("ERROR: $message\n", Empir::ERR_COLOR);
|
|
|
|
return $errno;
|
|
}
|
|
|
|
protected function success($message)
|
|
{
|
|
echo Color::str("$message\n", Empir::SUCCESS_COLOR);
|
|
}
|
|
|
|
protected function makeAbsolut($path='')
|
|
{
|
|
$current = getcwd().'/';
|
|
if($path == "" || $path == false)
|
|
$absolut_path = $current;
|
|
elseif(substr($path, 0, 2) == './')
|
|
$absolut_path = $current.substr($path,2);
|
|
elseif(strpos($path, ':') !== false || substr($path, 0, 2) == '\\\\' || substr($path, 0, 1) == '/')
|
|
$absolut_path = $path;
|
|
else
|
|
$absolut_path = $current.$path;
|
|
|
|
$absolut_path = str_replace('\\', '/', $absolut_path);
|
|
$absolut_path = rtrim($absolut_path, '/');
|
|
|
|
return $absolut_path;
|
|
}
|
|
|
|
private function find_opt($opt)
|
|
{
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manage phar
|
|
*
|
|
* @package Empir
|
|
* @author Jeremy Perret <j.perret.27@gmail.com>
|
|
*/
|
|
class Empir extends CLI_Interface
|
|
{
|
|
const VERSION = '1.0.0';
|
|
const ERR_COLOR = 'red';
|
|
const HELP_COLOR = 'green';
|
|
const PARAM_COLOR = 'purple';
|
|
const SUCCESS_COLOR = 'green';
|
|
|
|
public $options = array();
|
|
public $command;
|
|
public $commands = array(
|
|
'help' => 'help',
|
|
'?' => 'help',
|
|
'-h' => 'help',
|
|
'make' => 'make',
|
|
'convert' => 'convert',
|
|
'extract' => 'extract'
|
|
);
|
|
public $compression_types = array('gz', 'bz2', 'no');
|
|
public $format_types = array('phar', 'tar', 'zip');
|
|
|
|
public function __construct($argv)
|
|
{
|
|
$this->options = array_slice($argv, 1);
|
|
|
|
$vars = array(
|
|
'gz' => array(
|
|
'name' => 'gz',
|
|
'extension' => 'zlib',
|
|
'mime' => '.gz',
|
|
'int_value' => Phar::GZ,
|
|
),
|
|
'bz2' => array(
|
|
'name' => 'bz2',
|
|
'extension' => 'bzip2',
|
|
'mime' => '.bz2',
|
|
'int_value' => Phar::BZ2,
|
|
),
|
|
'no' => array(
|
|
'name' => 'no',
|
|
'extension' => 'not',
|
|
'mime' => '',
|
|
'int_value' => Phar::NONE,
|
|
),
|
|
'phar' => array(
|
|
'name' => 'phar',
|
|
'mime' => '.phar',
|
|
'int_value' => Phar::PHAR,
|
|
'compression' => true
|
|
),
|
|
'tar' => array(
|
|
'name' => 'tar',
|
|
'mime' => '.tar',
|
|
'int_value' => Phar::TAR,
|
|
'compression' => true
|
|
),
|
|
'zip' => array(
|
|
'name' => 'zip',
|
|
'mime' => '.zip',
|
|
'int_value' => Phar::ZIP,
|
|
'compression' => false
|
|
)
|
|
);
|
|
foreach($vars as $name => $attrs)
|
|
$this->$name = $this->array_to_object($attrs);
|
|
}
|
|
|
|
public function run()
|
|
{
|
|
$this->command = ($this->gopt(0) != null) ? $this->gopt(0) : 'help';
|
|
$this->options = array_slice($this->options, 1);
|
|
|
|
return $this->execCommand();
|
|
}
|
|
|
|
public function make()
|
|
{
|
|
$this->_is_phar_writable();
|
|
$phar = $this->makeAbsolut($this->reqopt(0, 'phar filename'));
|
|
$phar_name = end(explode('/', $phar));
|
|
$stub_file = trim($this->reqopt(1, 'stub file'), '/');
|
|
$root_app = $this->makeAbsolut($this->reqopt(2, 'root dir of your app'));
|
|
$_compression = $this->glopt('compress') ?: 'no';
|
|
$_format = $this->glopt('format') ?: 'phar';
|
|
$_exclude = $this->glopt('exclude');
|
|
$_fexclude = $this->glopt('fexclude');
|
|
|
|
if(!file_exists($root_app)) return $this->error("Root dir of your app doesn't exist.");
|
|
|
|
if(!empty($_compression) && !in_array($_compression, $this->compression_types)) return $this->error("Unrecognized compression: $_compression");
|
|
if(!empty($_format) && !in_array($_format, $this->format_types)) return $this->error("Unrecognized format: $_format");
|
|
|
|
if (!empty($_fexclude)) {
|
|
$_fexclude = $this->makeAbsolut($_fexclude);
|
|
if(!file_exists($_fexclude)) return $this->error("Exclude file: $_fexclude not found.");
|
|
$_fexclude = file_get_contents($_fexclude);
|
|
}
|
|
|
|
$shell_masks = explode('|', $_exclude);
|
|
$shell_masks = array_merge($shell_masks, explode("\n", $_fexclude));
|
|
|
|
$c = $this->get_var($_compression);
|
|
$f = $this->get_var($_format);
|
|
|
|
if (file_exists($phar)) {
|
|
unlink($phar);
|
|
}
|
|
|
|
try {
|
|
$p = new Phar($phar, Phar::CURRENT_AS_FILEINFO | Phar::KEY_AS_FILENAME, $phar_name);
|
|
|
|
echo "Make $phar_name : \n===================\n";
|
|
$project = json_decode(file_get_contents('composer.json'));
|
|
$p->setStub(
|
|
"#!/usr/bin/env php \n"
|
|
. "<?php\n"
|
|
. 'define("IN_PHAR", true);' . "\n"
|
|
. '$project = (object) array(' . "\n"
|
|
. " 'description' => '$project->description', " . "\n"
|
|
. " 'version' => '$project->version'," . "\n"
|
|
. " 'selfupdatepath' => '$project->selfupdatepath'," . "\n"
|
|
. " 'selfupdateversion' => '$project->selfupdateversion'," . "\n"
|
|
. ");" . "\n"
|
|
. "Phar::mapPhar(); " . "\n"
|
|
. "include 'phar://".$phar_name."/".$stub_file."'; " . "\n"
|
|
. "__HALT_COMPILER(); " . "\n"
|
|
. "?>" . "\n"
|
|
);
|
|
|
|
$files = $this->_scandir($root_app);
|
|
|
|
$i=0;
|
|
foreach ($files as $file) {
|
|
$file_buff = $file;
|
|
$file = str_replace('\\', '/', $file);
|
|
$file = str_replace($root_app.'/', '', $file);
|
|
|
|
if (!$this->_exclude($file, $shell_masks) && !$this->_exclude($file, array('*/'.$phar_name, $phar_name))) {
|
|
echo "add $file\n";
|
|
//$p[$file] = php_strip_whitespace($file_buff);
|
|
$p[$file] = file_get_contents($file_buff);
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
echo "\nTotal: $i files added\n";
|
|
|
|
if ($f->name == 'phar' && $c->name='no') {
|
|
$this->success("CREATE $phar");
|
|
|
|
return;
|
|
}
|
|
|
|
if(!Phar::canCompress($c->int_value)) return $this->error("Unable to compress the phar with $c->name, extension $c->extension not found. But $phar is created.");
|
|
|
|
if(!$f->compression) $c->int_value = Phar::NONE;
|
|
|
|
$phar_copy = $phar.$f->mime.$c->mime;
|
|
@unlink($phar_copy);
|
|
$p = $p->convertToExecutable($f->int_value, $c->int_value);
|
|
$this->success("CREATE $phar_copy");
|
|
@unlink($phar);
|
|
} catch (Exception $e) {
|
|
return $this->error($e->getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
public function help()
|
|
{
|
|
$help = new Help();
|
|
$command = $this->gopt(0);
|
|
if(empty($command)) return $help->main();
|
|
|
|
switch ($command) {
|
|
case 'make': $help->make(); break;
|
|
default: return $this->error("Command: $command doesn't exist."); break;
|
|
}
|
|
}
|
|
|
|
private function _is_phar_writable()
|
|
{
|
|
if(!Phar::canWrite()) exit($this->error("Unable to write phar, phar.readonly must be set to zero in your php.ini otherwise use: $ php -dphar.readonly=0 empir <command> ..."));
|
|
}
|
|
|
|
private function get_var($var)
|
|
{
|
|
if (is_string($var)) {
|
|
if(isset($this->$var))
|
|
|
|
return $this->$var;
|
|
} else {
|
|
foreach (array_merge($this->compression_types, $this->format_types) as $v) {
|
|
if($this->$v->int_value == $var)
|
|
|
|
return $this->$v;
|
|
}
|
|
}
|
|
}
|
|
|
|
private function _exclude($file, $shell_masks)
|
|
{
|
|
if (!empty($shell_masks)) {
|
|
foreach ($shell_masks as $mask) {
|
|
if(fnmatch(trim($mask), $file))
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function _scandir($path)
|
|
{
|
|
$items = array();
|
|
$path = rtrim($path, '/');
|
|
if (!$current_dir = opendir($path))
|
|
return $items;
|
|
|
|
while (false !== ($filename = readdir($current_dir))) {
|
|
if ($filename != "." && $filename != "..") {
|
|
if (is_dir($path.'/'.$filename)) {
|
|
$items = array_merge($items, $this->_scandir($path.'/'.$filename));
|
|
} else
|
|
$items[] = $path.'/'.$filename;
|
|
}
|
|
}
|
|
closedir($current_dir);
|
|
|
|
return $items;
|
|
}
|
|
|
|
private function array_to_object($array)
|
|
{
|
|
$object = new stdClass();
|
|
foreach ($array as $name => $value) {
|
|
$name = strtolower(trim($name));
|
|
if (!empty($name))
|
|
$object->$name = $value;
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Colorizer
|
|
*
|
|
* @package Empir
|
|
* @author Jeremy Perret <j.perret.27@gmail.com>
|
|
*/
|
|
class Color
|
|
{
|
|
public static $foreground_colors = array(
|
|
'black' => '0;30',
|
|
'dark_gray' => '1;30',
|
|
'blue' => '0;34',
|
|
'light_blue' => '1;34',
|
|
'green' => '0;32',
|
|
'light_green' => '1;32',
|
|
'cyan' => '0;36',
|
|
'light_cyan' => '1;36',
|
|
'red' => '0;31',
|
|
'light_red' => '1;31',
|
|
'purple' => '0;35',
|
|
'light_purple' => '1;35',
|
|
'brown' => '0;33',
|
|
'yellow' => '1;33',
|
|
'light_gray' => '0;37',
|
|
'white' => '1;37'
|
|
);
|
|
|
|
public static $background_colors = array(
|
|
'black' => '40',
|
|
'red' => '41',
|
|
'green' => '42',
|
|
'yellow' => '43',
|
|
'blue' => '44',
|
|
'magenta' => '45',
|
|
'cyan' => '46',
|
|
'light_gray' => '47'
|
|
);
|
|
|
|
public static function str($string, $foreground_color = null, $background_color = null)
|
|
{
|
|
if(!self::isTermSupportColor()) return $string;
|
|
|
|
$colored_string = "";
|
|
|
|
if (isset(self::$foreground_colors[$foreground_color])) {
|
|
$colored_string .= "\033[".self::$foreground_colors[$foreground_color]."m";
|
|
}
|
|
|
|
if (isset(self::$background_colors[$background_color])) {
|
|
$colored_string .= "\033[".self::$background_colors[$background_color]."m";
|
|
}
|
|
|
|
$colored_string .= $string."\033[0m";
|
|
|
|
return $colored_string;
|
|
}
|
|
|
|
public static function random($string)
|
|
{
|
|
$index_foreground = array_rand(self::$foreground_colors, 1);
|
|
$index_background= array_rand(self::$background_colors, 1);
|
|
|
|
return self::str($string, $index_foreground, $index_background);
|
|
}
|
|
|
|
public static function isTermSupportColor()
|
|
{
|
|
$term = getenv('TERM');
|
|
if($term && ACTIVATE_COLORS) return true;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* All differents helps.
|
|
*
|
|
* @package Empir
|
|
* @author Jeremy Perret <j.perret.27@gmail.com>
|
|
*/
|
|
class Help
|
|
{
|
|
public function main()
|
|
{
|
|
echo "Empir v".Empir::VERSION." 2010 (c) Jeremy Perret <j.perret.27@gmail.com>
|
|
Empir is a php tool to manage phar.
|
|
The setting phar.readonly must be 0 in your php.ini,
|
|
otherwise use $ php -dphar.readonly=0 empir <command> ...
|
|
If you use Empir from PEAR installation don't care about this php option,
|
|
it used directly in the executable file.
|
|
|
|
".Color::str('Usage', Empir::HELP_COLOR).":
|
|
$ php empir <command> <parameters> [options]
|
|
|
|
".Color::str('Commands', Empir::HELP_COLOR).":
|
|
".Color::str('make', Empir::PARAM_COLOR)." Create a phar from an entire php application.
|
|
|
|
For more help on a command use 'empir help <command>'
|
|
";
|
|
}
|
|
|
|
public function make()
|
|
{
|
|
echo "Command make allows to create a phar file from an entire php application from its root directory.
|
|
|
|
".Color::str('Usage', Empir::HELP_COLOR).":
|
|
$ php empir make <phar_file> <stub_file> <root_app> [options]
|
|
|
|
".Color::str('Parameters', Empir::HELP_COLOR).":
|
|
".Color::str('phar_file', Empir::PARAM_COLOR)." Phar file that will be created, accept absolute or relative path.
|
|
".Color::str('stub_file', Empir::PARAM_COLOR)." Bootstrap file of your application, from your root app folder.
|
|
".Color::str('root_app', Empir::PARAM_COLOR)." Root folder of your application, accept absolute or relative path.
|
|
|
|
".Color::str('Options', Empir::HELP_COLOR).":
|
|
".Color::str('--exclude=PATTERN', Empir::PARAM_COLOR)." Exclude files match PATTERN, seperate several patterns with a pipe.
|
|
".Color::str('--fexclude=FILE', Empir::PARAM_COLOR)." Exclude patterns listed in FILE. One pattern per line.
|
|
".Color::str('--format=FORMAT', Empir::PARAM_COLOR)." Special phar format, FORMAT can be tar or zip. Don't specify format to keep normal phar.
|
|
".Color::str('--compress=TYPE', Empir::PARAM_COLOR)." Specify the phar compression type. TYPE can be gz or bz2.
|
|
";
|
|
}
|
|
}
|
|
|