CLI.php

<?php
/*
 * This file is part of XRL, a simple XML-RPC Library for PHP.
 *
 * Copyright (c) 2012, XRL Team. All rights reserved.
 * XRL is licensed under the 3-clause BSD License.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace fpoirotte\XRL;

class CLI
{
    public static function getVersion()
    {
        static $version = null;

        // Return cached version if possible.
        if (null !== $version) {
            return $version;
        }

        // From a phar release.
        if (!strncmp('phar://', __FILE__, 7)) {
            $phar = new \Phar(dirname(__DIR__));
            $md = $phar->getMetadata();
            $version = $md['version'];
        } else {
            // From a composer install.
            $getver = dirname(__DIR__) .
                        DIRECTORY_SEPARATOR . 'vendor' .
                        DIRECTORY_SEPARATOR . 'erebot' .
                        DIRECTORY_SEPARATOR . 'buildenv' .
                        DIRECTORY_SEPARATOR . 'get_version.php';
            if (file_exists($getver)) {
                $version = trim(shell_exec($getver));
            } else {
                // Default guess
                $version = 'dev';
            }
        }

        return $version;
    }

    public static function getCopyrightAndLicense()
    {
        return str_replace(
            "\n",
            PHP_EOL,
            file_get_contents(
                dirname(__DIR__) .
                DIRECTORY_SEPARATOR .
                'LICENSE'
            )
        );
    }

    public function printUsage($output, $prog)
    {
        $usageFile  = dirname(__DIR__) .
                        DIRECTORY_SEPARATOR . 'data' .
                        DIRECTORY_SEPARATOR . 'usage.txt';
        $usage      = @file_get_contents($usageFile);
        $usage      = str_replace(array("\r\n", "\r"), "\n", $usage);
        $usage      = trim($usage);
        $output->write($usage, $prog, 'http://xmlrpc.example.com/');
    }

    protected function parseBool($value)
    {
        $value = strtolower($value);
        if (in_array($value, array('0', 'off', 'false'))) {
            return false;
        }
        if (in_array($value, array('1', 'on', 'true'))) {
            return true;
        }
        throw new \Exception('Invalid value "'.$value.'" for type "bool"');
    }

    protected function parseFile($value)
    {
        $content = @file_get_contents($value);
        if ($content === false) {
            throw new \Exception('Could not read content of "'.$value.'"');
        }
        return $content;
    }

    protected function parseTimestamp($value)
    {
        $result = new \DateTime($value);
        // Older versions of PHP returned false for invalid
        // values instead of throwing an exception.
        if (!$result) {
            throw new \Exception('Invalid datetime value "'.$value.'"');
        }
        return $result;
    }

    protected function parseParam(array &$args, \DateTimeZone $timezone)
    {
        if (!count($args)) {
            throw new \Exception('Not enough arguments.');
        }

        $type = strtolower(array_shift($args));
        $parseFunc = null;
        switch ($type) {
            case 'null':
            case 'nil':
            case 'n':
                return null;
                break;

            case 'boolean':
            case 'bool':
            case 'b':
                $parseFunc = array($this, 'parseBool');
                break;

            case 'integer':
            case 'int':
            case 'i4':
            case 'i':
                $parseFunc = 'intval';
                break;

            case 'double':
            case 'float':
            case 'f':
                $parseFunc = 'floatval';
                break;

            case 'string':
            case 'str':
            case 's':
                $parseFunc = 'strval';
                break;

            case 'file':
            case '@':
                $parseFunc = array($this, 'parseFile');
                break;

            case 'timestamp':
            case 'datetime':
            case 'date':
            case 'time':
            case 'ts':
            case 'dt':
            case 't':
            case 'd':
                $parseFunc = array($this, 'parseTimestamp');
                break;

            case 'hash':
            case 'h':
                $result = array();
                while (true) {
                    if (!count($args)) {
                        throw new \Exception('Not enough arguments for "hash".');
                    }

                    if (in_array(strtolower($args[0]), array('endhash', 'eh'))) {
                        break;
                    }

                    $key = $this->parseParam($args, $timezone);
                    if (!is_int($key) && !is_string($key)) {
                        throw new \Exception(
                            'Invalid type "'.gettype($key).'" for hash key. '.
                            'Only integer and string keys may be used.'
                        );
                    }
                    $value = $this->parseParam($args, $timezone);
                    $result[$key] = $value;
                }
                // Pop the ending "endhash".
                array_shift($args);
                return $result;

            case 'list':
            case 'l':
                $result = array();
                while (true) {
                    if (!count($args)) {
                        throw new \Exception('Not enough arguments for "list".');
                    }

                    if (in_array(strtolower($args[0]), array('endlist', 'el'))) {
                        break;
                    }

                    $result[] = $this->parseParam($args, $timezone);
                }
                // Pop the ending "endlist".
                array_shift($args);
                return $result;

            default:
                throw new \Exception('Unknown type "'.$type.'".');
        }

        if (!count($args)) {
            throw new \Exception('Not enough arguments.');
        }

        $value = array_shift($args);
        $value = call_user_func($parseFunc, $value);
        if ($value instanceof \DateTime) {
            $value->setTimezone($timezone);
        }
        return $value;
    }

    protected function parse(array $args)
    {
        $params     = array(
            'serverURL'     => null,
            'procedure'     => null,
            'additional'    => array(),
        );
        $options    = array(
            'd' => false,
            'h' => false,
            'n' => false,
            't' => new \DateTimeZone(@date_default_timezone_get()),
            'v' => 0,
            'V' => false,
            'x' => false,
        );

        while (count($args)) {
            $v = array_shift($args);

            if ($params['serverURL'] === null) {
                if (substr($v, 0, 1) == '-') {
                    $p = array();
                    $v = (string) substr($v, 1);
                    foreach (str_split($v) as $o) {
                        if (!array_key_exists($o, $options)) {
                            throw new \Exception(
                                'Unknown option "'.$o.'". '.
                                'Use -h to get help.'
                            );
                        }

                        if (is_bool($options[$o])) {
                            $options[$o] = true;
                        } elseif (is_int($options[$o])) {
                            $options[$o]++;
                        } else {
                            $p[] = $o;
                        }
                    }

                    foreach ($p as $o) {
                        if (!count($args)) {
                            throw new \Exception(
                                'Not enough arguments for option "'.$o.'".'
                            );
                        }
                        $v = array_shift($args);
                        if (!($options[$o] instanceof \DateTimeZone)) {
                            $options[$o] = new \DateTimeZone($v);
                        }
                    }
                } else {
                    $params['serverURL'] = $v;
                }
                continue;
            }

            if ($params['procedure'] === null) {
                $params['procedure'] = $v;
                break;
            }
        }

        while (count($args)) {
            $params['additional'][] = $this->parseParam($args, $options['t']);
        }

        return array($options, $params);
    }

    public function run(array $args)
    {
        $prog = array_shift($args);
        try {
            list($options, $params) = $this->parse($args);
        } catch (\Exception $e) {
            fprintf(STDERR, '%s: %s' . PHP_EOL, $prog, $e->getMessage());
            return 2;
        }

        // Show help.
        if ($options['h']) {
            $this->printUsage(new \fpoirotte\XRL\Output(STDOUT), $prog);
            return 0;
        }

        // Show version.
        if ($options['V']) {
            $version = self::getVersion();
            $license = self::getCopyrightAndLicense();
            echo 'XRL version ' . $version . PHP_EOL;
            echo PHP_EOL . $license . PHP_EOL;
            echo 'Visit https://github.com/fpoirotte/XRL for more!' . PHP_EOL;
            return 0;
        }

        // Do we have enough arguments to do something?
        if ($params['serverURL'] === null || $params['procedure'] === null) {
            $this->printUsage(new \fpoirotte\XRL\Output(STDERR), $prog);
            return 2;
        }

        // Then let's do it!
        $encoder    = new \fpoirotte\XRL\NativeEncoder(new \fpoirotte\XRL\Encoder($options['t'], true));
        $decoder    = new \fpoirotte\XRL\NativeDecoder(new \fpoirotte\XRL\Decoder($options['t'], $options['x']));
        $request    = new \fpoirotte\XRL\Request($params['procedure'], $params['additional']);

        // Change verbosity as necessary.
        if (class_exists('\\Plop\\Plop')) {
            $logging = \Plop\Plop::getInstance();
            $logging->getLogger()->setLevel(40 - min(4, $options['v']) * 10);
        } else {
            $logging = null;
        }

        // Prepare the request.
        $xml = $encoder->encodeRequest($request);
        $logging and $logging->debug(
            "Request:\n%(request)s",
            array('request' => $xml)
        );
        if ($options['n']) {
            echo 'Not sending the actual query due to dry run mode.' . PHP_EOL;
            return 0;
        }

        $headers    = array(
            'Content-Type: text/xml',
            'User-Agent: XRL/' . static::getVersion(),
        );

        // Prepare the context.
        $ctxOptions = array(
            'http' => array(
                'method'    => 'POST',
                'content'   => $xml,
                'header'    => $headers,
            ),
        );
        $context = stream_context_create($ctxOptions);
        libxml_set_streams_context($context);

        // Send the request and process the response.
        try {
            $result = $decoder->decodeResponse($params['serverURL']);
        } catch (\Exception $result) {
            // Nothing to do.
        }

        echo 'Result:' . PHP_EOL . print_r($result, true) . PHP_EOL;
        return 0;
    }
}