make.php

<?php

class Option {

    var $default = false;

    function __construct($options=false) {
        list($this->short, $this->long) = array_slice($options, 0, 2);
        $this->help = (isset($options['help'])) ? $options['help'] : "";
        $this->action = (isset($options['action'])) ? $options['action']
            : "store";
        $this->dest = (isset($options['dest'])) ? $options['dest']
            : substr($this->long, 2);
        $this->type = (isset($options['type'])) ? $options['type']
            : 'string';
        $this->const = (isset($options['const'])) ? $options['const']
            : null;
        $this->default = (isset($options['default'])) ? $options['default']
            : null;
        $this->metavar = (isset($options['metavar'])) ? $options['metavar']
            : 'var';
        $this->nargs = (isset($options['nargs'])) ? $options['nargs']
            : 1;
    }

    function hasArg() {
        return $this->action != 'store_true'
            && $this->action != 'store_false';
    }

    function handleValue(&$destination, $args) {
        $nargs = 0;
        $value = ($this->hasArg()) ? array_shift($args) : null;
        if ($value[0] == '-')
            $value = null;
        elseif ($value)
            $nargs = 1;
        if ($this->type == 'int')
            $value = (int)$value;
        switch ($this->action) {
            case 'store_true':
                $value = true;
                break;
            case 'store_false':
                $value = false;
                break;
            case 'store_const':
                $value = $this->const;
                break;
            case 'append':
                if (!isset($destination[$this->dest]))
                    $destination[$this->dest] = array($value);
                else {
                    $T = &$destination[$this->dest];
                    $T[] = $value;
                    $value = $T;
                }
                break;
            case 'store':
            default:
                break;
        }
        $destination[$this->dest] = $value;
        return $nargs;
    }

    function toString() {
        $short = explode(':', $this->short);
        $long = explode(':', $this->long);
        if ($this->nargs === '?')
            $switches = sprintf('    %s [%3$s], %s[=%3$s]', $short[0],
                $long[0], $this->metavar);
        elseif ($this->hasArg())
            $switches = sprintf('    %s %3$s, %s=%3$s', $short[0], $long[0],
                $this->metavar);
        else
            $switches = sprintf("    %s, %s", $short[0], $long[0]);
        $help = preg_replace('/\s+/', ' ', $this->help);
        if (strlen($switches) > 23)
            $help = "\n" . str_repeat(" ", 24) . $help;
        else
            $switches = str_pad($switches, 24);
        $help = wordwrap($help, 54, "\n" . str_repeat(" ", 24));
        return $switches . $help;
    }
}

class OutputStream {
    var $stream;

    function __construct($stream) {
        $this->stream = fopen($stream, 'w');
    }

    function write($what) {
        fwrite($this->stream, $what);
    }
}

class Module {

    var $options = array();
    var $arguments = array();
    var $prologue = "";
    var $epilog = "";
    var $usage = '$script [options] $args [arguments]';
    var $autohelp = true;
    var $module_name;

    var $stdout;
    var $stderr;

    var $_options;
    var $_args;

    function __construct() {
        $this->options['help'] = array("-h","--help",
            'action'=>'store_true',
            'help'=>"Display this help message");
        foreach ($this->options as &$opt)
            $opt = new Option($opt);
        $this->stdout = new OutputStream('php://output');
        $this->stderr = new OutputStream('php://stderr');
    }

    function showHelp() {
        if ($this->prologue)
            echo $this->prologue . "\n\n";

        global $argv;
        $manager = @$argv[0];

        echo "Usage:\n";
        echo "    " . str_replace(
                array('$script', '$args'),
                array($manager ." ". $this->module_name, implode(' ', array_keys($this->arguments))),
            $this->usage) . "\n";

        ksort($this->options);
        if ($this->options) {
            echo "\nOptions:\n";
            foreach ($this->options as $name=>$opt)
                echo $opt->toString() . "\n";
        }

        if ($this->arguments) {
            echo "\nArguments:\n";
            foreach ($this->arguments as $name=>$help) {
                $extra = '';
                if (isset($help['options']) && is_array($help['options'])) {
                    foreach($help['options'] as $op=>$desc)
                        $extra .= wordwrap(
                            "\n        $op - $desc", 76, "\n            ");
                }
                $help = $help['help'];
                echo $name . "\n    " . wordwrap(
                    preg_replace('/\s+/', ' ', $help), 76, "\n    ")
                        .$extra."\n";
            }
        }

        if ($this->epilog) {
            echo "\n\n";
            $epilog = preg_replace('/\s+/', ' ', $this->epilog);
            echo wordwrap($epilog, 76, "\n");
        }

        echo "\n";
    }

    function fail($message, $showhelp=false) {
        $this->stderr->write($message . "\n");
        if ($showhelp)
            $this->showHelp();
        die();
    }

    function getOption($name, $default=false) {
        $this->parseOptions();
        if (isset($this->_options[$name]))
            return $this->_options[$name];
        elseif (isset($this->options[$name]) && $this->options[$name]->default)
            return $this->options[$name]->default;
        else
            return $default;
    }

    function getArgument($name, $default=false) {
        $this->parseOptions();
        if (isset($this->_args[$name]))
            return $this->_args[$name];
        return $default;
    }

    function parseOptions() {
        if (is_array($this->_options))
            return;

        global $argv;
        list($this->_options, $this->_args) =
            $this->parseArgs(array_slice($argv, 1));

        foreach (array_keys($this->arguments) as $idx=>$name) {
            if (!is_array($this->arguments[$name]))
                $this->arguments[$name] = array(
                    'help' => $this->arguments[$name]);
            $this->arguments[$name]['idx'] = $idx;
        }

        foreach ($this->arguments as $name=>$info) {
            if (!isset($this->_args[$info['idx']])) {
                if (isset($info['required']) && !$info['required'])
                    continue;
                $this->optionError($name . " is a required argument");
            }
            else {
                $this->_args[$name] = &$this->_args[$info['idx']];
            }
        }

        foreach ($this->options as $name=>$opt)
            if (!isset($this->_options[$name]))
                $this->_options[$name] = $opt->default;

        if ($this->autohelp && $this->getOption('help')) {
            $this->showHelp();
            die();
        }
    }

    function optionError($error) {
        echo "Error: " . $error . "\n\n";
        $this->showHelp();
        die();
    }

    function _run($module_name) {
        $this->module_name = $module_name;
        $this->parseOptions();
        return $this->run($this->_args, $this->_options);
    }

    /* abstract */
    function run($args, $options) {
    }

    /* static */
    function register($action, $class) {
        global $registered_modules;
        $registered_modules[$action] = new $class();
    }

    /* static */ function getInstance($action) {
        global $registered_modules;
        return $registered_modules[$action];
    }

    function parseArgs($argv) {
        $options = $args = array();
        $argv = array_slice($argv, 0);
        while ($arg = array_shift($argv)) {
            if (strpos($arg, '=') !== false) {
                list($arg, $value) = explode('=', $arg, 2);
                array_unshift($argv, $value);
            }
            $found = false;
            foreach ($this->options as $opt) {
                if ($opt->short == $arg || $opt->long == $arg) {
                    if ($opt->handleValue($options, $argv))
                        array_shift($argv);
                    $found = true;
                }
            }
            if (!$found && $arg[0] != '-')
                $args[] = $arg;
        }
        return array($options, $args);
    }
}

class PluginBuilder extends Module {
    var $prologue =
        "Inspects, tests, and builds a plugin PHAR file";

    var $arguments = array(
        'action' => array(
            'help' => "What to do with the plugin",
            'options' => array(
                'build' => 'Compile a PHAR file for a plugin',
                'hydrate' => 'Prep plugin folders for embedding in osTicket directly',
                'list' => 'List the contents of a phar file',
                'unpack' => 'Unpack a PHAR file (similar to unzip)',
            ),
        ),
        'plugin' => array(
            'help' => "Plugin to be compiled",
            'required' => false
        ),
    );

    var $options = array(
        'sign' => array('-S','--sign', 'metavar'=>'KEY', 'help'=>
            'Sign the compiled PHAR file with the provided OpenSSL private
            key file'),
        'verbose' => array('-v','--verbose','help'=>
            'Be more verbose','default'=>false, 'action'=>'store_true'),
        'compress' => array('-z', '--compress', 'help' =>
            'Compress source files when hydrading and building. Useful for
            saving space when building PHAR files',
            'action'=>'store_true', 'default'=>false),
        "key" => array('-k','--key','metavar'=>'API-KEY',
            'help'=>'Crowdin project API key.'),
        'osticket' => array('-R', '--osticket', 'metavar'=>'ROOT',
            'help'=>'Root of osTicket installation (required for language compilation)'),
    );

    static $project = 'osticket-plugins';
    static $crowdin_api_url = 'http://i18n.osticket.com/api/project/{project}/{command}';

    function run($args, $options) {
        $this->key = $options['key'];
        if (!$this->key && defined('CROWDIN_API_KEY'))
            $this->key = CROWDIN_API_KEY;

        if (@$options['osticket']) {
            require $options['osticket'] . '/include/class.translation.php';
        }

        switch (strtolower($args['action'])) {
        case 'build':
            $plugin = $args['plugin'];

            if (!file_exists($plugin))
                $this->fail("Plugin folder '$plugin' does not exist");

            $this->_build($plugin, $options);
            break;

        case 'hydrate':
            $this->_hydrate($options);
            break;
        case 'list':
            $P = new Phar($args[1]);
            $base = realpath($args[1]);
            foreach (new RecursiveIteratorIterator($P) as $finfo) {
                $name = str_replace('phar://'.$base.'/', '', $finfo->getPathname());
                $this->stdout->write($name . "\n");
            }
            break;

        case 'list':
            $plugin = $args['plugin'];
            if (!file_exists($plugin))
                $this->fail("PHAR file '$plugin' does not exist");

            $p = new Phar($plugin);
            $total = 0;
            foreach (new RecursiveIteratorIterator($p) as $info) {
                $this->stdout->write(sprintf(
                    "% 10.10d  %s  %s\n",
                    $info->getSize(),
                    strftime('%x %X', $info->getMTime()),
                    str_replace(
                        array('phar://', realpath($plugin).'/'),
                        array('',''),
                        (string) $info)));
                $total += $info->getSize();
            }
            $this->stdout->write("---------------------------------------\n");
            $this->stdout->write(sprintf("% 10.10d\n", $total));
            break;

        default:
            $this->fail("Unsupported MAKE action. See help");
        }
    }

    function _build($plugin, $options) {
        @unlink("$plugin.phar");
        $phar = new Phar("$plugin.phar");
        $phar->startBuffering();

        if ($options['sign']) {
            if (!function_exists('openssl_get_privatekey'))
                $this->fail('OpenSSL extension required for signing');
            $private = openssl_get_privatekey(
                    file_get_contents($options['sign']));
            $pkey = '';
            openssl_pkey_export($private, $pkey);
            $phar->setSignatureAlgorithm(Phar::OPENSSL, $pkey);
        }

        // Read plugin info
        $info = (include "$plugin/plugin.php");

        $this->resolveDependencies(false);

        $phar->buildFromDirectory($plugin);

        // Add library dependencies
        if (isset($info['requires'])) {
            $includes = array();
            foreach ($info['requires'] as $lib=>$info) {
                if (!isset($info['map']))
                    continue;
                foreach ($info['map'] as $lib=>$local) {
                    if (preg_match('/{+(.*?)}/', $lib))
                        $lib = dirname($lib);
                    $phar_path = trim($local, '/').'/';
                    $full = rtrim(dirname(__file__).'/lib/'.$lib,'/').'/';
                    $files = new RecursiveIteratorIterator(
                        new RecursiveDirectoryIterator($full),
                            RecursiveIteratorIterator::SELF_FIRST);
                    foreach ($files as $f) {
                        if (file_exists("$plugin/$phar_path"))
                            // Hydrated
                            continue;
                        elseif ($f->isDir())
                            // Unnecessary
                            continue;
                        elseif (preg_match('`/tests?/`i', $f->getPathname()))
                            // Don't package tests
                            // XXX: Add a option to override this
                            continue;
                        $content = '';
                        $local = str_replace($full, $phar_path, $f->getPathname());
                        if ($options['compress'] && fnmatch('*.php', $f->getPathname())) {
                            $p = popen('php -w '.realpath($f->getPathname()), 'r');
                            while ($b = fread($p, 8192))
                                $content .= $b;
                            fclose($p);
                            $phar->addFromString($local, $content);
                        }
                        else {
                            $phar->addFile($f->getPathname(), $local);
                        }
                    }
                }
            }
        }

        // Add language files
        if (@$this->key) {
            foreach ($this->getLanguageFiles($plugin) as $name=>$content) {
                $name = ltrim($name, '/');
                if (!$content) continue;
                $phar->addFromString("i18n/{$name}", $content);
            }
        }
        else {
            $this->stderr->write("Specify Crowdin API key to integrate language files\n");
        }

        $phar->setStub('<?php __HALT_COMPILER();');
        $phar->stopBuffering();
    }

    function _hydrate($options) {
        $this->resolveDependencies();

        // Move things into place
        foreach (glob(dirname(__file__).'/*/plugin.php') as $plugin) {
            $p = (include $plugin);
            if ((!isset($p['requires']) || !is_array($p['requires'])) && !isset($p['map']))
                continue;
            if (isset($p['requires'])) {
                foreach ($p['requires'] as $lib=>$info) {
                    // Map composer dependencies
                    if (!isset($info['map']) || !is_array($info['map']))
                        continue;
                    foreach ($info['map'] as $lib=>$local) {
                        $source = dirname(__file__).'/lib/'.$lib;
                        $dest = dirname($plugin).'/'.$local;
                        $this->mapDependencies($options, $lib, $local, $source, $dest);
                    }
                    // TODO: Fetch language files for this plugin
                }
            }
            // Map custom dependencies
            if (!isset($p['map']) || !is_array($p['map']))
                continue;
            foreach ($p['map'] as $lib=>$local) {
                $source = dirname(__file__).'/lib/'.$lib;
                $dest = dirname($plugin).'/'.$local;
                $this->mapDependencies($options, $lib, $local, $source, $dest);
            }
        }
    }

    function mapDependencies($options, $lib, $local, $source, $dest) {
        if ($this->options['verbose']) {
            $left = str_replace(dirname(__file__).'/', '', $source);
            $right = str_replace(dirname(__file__).'/', '', $dest);
            $this->stdout->write("Hydrating :: $left => $right\n");
        }
        if (is_file($source)) {
            copy($left, $right);
            return;
        }

        // See if we need to do filtering via expandable search
        if (preg_match('/{+(.*?)}/', $source)) {
            foreach (glob($source, GLOB_BRACE) as $_source)
                $this->mapDependencies($options, $lib, $local, $_source,
                 ($dest.'/'.basename($_source)));
            return;
        }

        foreach (
            $iterator = new RecursiveIteratorIterator(
                new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
                    RecursiveIteratorIterator::SELF_FIRST) as $item
        ) {
            if ($item->isDir())
                continue;

            $target = $dest . DIRECTORY_SEPARATOR . $iterator->getSubPathName();
            $parent = dirname($target);
            if (!file_exists($parent))
                mkdir($parent, 0777, true);
            // Compress PHP files
            if ($options['compress'] && fnmatch('*.php', $item)) {
                $p = popen('php -w '.realpath($item), 'r');
                $T = fopen($target, 'w');
                while ($b = fread($p, 8192))
                    fwrite($T, $b);
                fclose($p);
                fclose($T);
            }
            else {
                copy($item, $target);
            }
        }
    }

    function _http_get($url) {
        #curl post
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_USERAGENT, 'osTicket-cli');
        curl_setopt($ch, CURLOPT_HEADER, FALSE);
        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, FALSE);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
        $result=curl_exec($ch);
        $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        return array($code, $result);
    }

    function _crowdin($command, $args=array()) {

        $url = str_replace(array('{command}', '{project}'),
            array($command, self::$project),
            self::$crowdin_api_url);

        $args += array('key' => $this->key);
        foreach ($args as &$a)
            $a = urlencode($a);
        unset($a);
        $url .= '?' . http_build_query($args);

        return $this->_http_get($url);
    }

    function getTranslations() {
        error_reporting(E_ALL);
        list($code, $body) = $this->_crowdin('status');
        $langs = array();

        if ($code != 200) {
            $this->stderr->write($code.": Bad status from Crowdin fetching translations\n");
            return $langs;
        }
        $d = new DOMDocument();
        $d->loadXML($body);

        $xp = new DOMXpath($d);
        foreach ($xp->query('//language') as $c) {
            $name = $code = '';
            foreach ($c->childNodes as $n) {
                switch (strtolower($n->nodeName)) {
                case 'name':
                    $name = $n->textContent;
                    break;
                case 'code':
                    $code = $n->textContent;
                    break;
                }
            }
            if (!$code)
                continue;
            $langs[] = $code;
        }
        return $langs;
    }

    function getLanguageFiles($plugin) {
        $files = array();
        if (!class_exists('Translation'))
            $this->stderr->write("Specify osTicket root path to compile MO files\n");

        foreach ($this->getTranslations() as $lang) {
            list($code, $stuff) = $this->_crowdin("download/$lang.zip");
            if ($code != 200) {
                $this->stderr->write("$lang: Unable to download language files\n");
                continue;
            }

            $lang = str_replace('-','_',$lang);

            // Extract a few files from the zip archive
            $temp = tempnam('/tmp', 'osticket-cli');
            $f = fopen($temp, 'w');
            fwrite($f, $stuff);
            fclose($f);
            $zip = new ZipArchive();
            $zip->open($temp);
            unlink($temp);

            for ($i=0; $i<$zip->numFiles; $i++) {
                $info = $zip->statIndex($i);
                if (strpos($info['name'], $plugin) === 0) {
                    $name = substr($info['name'], strlen($plugin));
                    $name = ltrim($name, '/');
                    if (substr($name, -3) == '.po' && class_exists('Translation')) {
                        $content = $this->buildMo($zip->getFromIndex($i));
                        $name = substr($name, 0, -3) . '.mo.php';
                    }
                    else {
                        $content = $zip->getFromIndex($i);
                    }
                    // Files in the plugin are laid out by (lang)/(file),
                    // where (file) has the plugin name removed. Files on
                    // Crowdin are organized by (plugin)/file
                    $files["$lang/{$name}"] = $content;
                }
            }
            $zip->close();
        }
        return $files;
    }

    function buildMo($po_contents) {
        $pipes = array();
        $msgfmt = proc_open('msgfmt -o- -',
            array(0=>array('pipe','r'), 1=>array('pipe','w')),
            $pipes);
        if (is_resource($msgfmt)) {
            fwrite($pipes[0], $po_contents);
            fclose($pipes[0]);
            $mo_input = fopen('php://temp', 'r+b');
            fwrite($mo_input, stream_get_contents($pipes[1]));
            rewind($mo_input);
            $mo = Translation::buildHashFile($mo_input, false, true);
            fclose($mo_input);
        }
        return $mo;
    }

    function ensureComposer() {
        if (file_exists(dirname(__file__).'/composer.phar'))
            return true;

        return static::getComposer();
    }

    function getComposer() {
        list($code, $phar) = $this->_http_get('https://getcomposer.org/composer-2.phar');

        if (!($fp = fopen(dirname(__file__).'/composer.phar', 'wb')))
            $this->fail('Cannot install composer: Unable to write "composer.phar"');

        fwrite($fp, $phar);
        fclose($fp);
    }

    function resolveDependencies($autoupdate=true) {
        // Build dependency list
        $requires = $scripts = $extra = [];
        foreach (glob(dirname(__file__).'/*/plugin.php') as $plugin) {
            $p = (include $plugin);
            if (isset($p['requires']))
                foreach ($p['requires'] as $lib=>$info)
                    $requires[$lib] = $info['version'];
            if (isset($p['scripts']))
                foreach ($p['scripts'] as $name=>$script)
                    $scripts[$name] = $script;
            if (isset($p['extra']))
                foreach ($p['extra'] as $package=>$namespaces)
                    $extra[$package] = $namespaces;
        }

        // Write composer.json file
        $composer = <<<EOF
{
    "name": "osticket/core-plugins",
    "require": %s,
    "config": {
        "vendor-dir": "lib"
    },
    "scripts": %s,
    "extra": %s
}
EOF;
        $composer = sprintf($composer, json_encode($requires), json_encode($scripts), json_encode($extra));

        if (!($fp = fopen('composer.json', 'w')))
            $this->fail('Unable to save "composer.json"');

        fwrite($fp, $composer);
        fclose($fp);

        $this->ensureComposer();

        $php = defined('PHP_BINARY') ? PHP_BINARY : 'php';
        if (file_exists(dirname(__file__)."/composer.lock")) {
            if ($autoupdate)
                passthru($php." ".dirname(__file__)."/composer.phar -v update");
        }
        else
            passthru($php." ".dirname(__file__)."/composer.phar -v install");
    }
}
$registered_modules = array();

if (php_sapi_name() != "cli")
    die("Management only supported from command-line\n");

$builder = new PluginBuilder();
$builder->parseOptions();
$builder->_run(basename(__file__));

?>