Args

In questo esempio vedremo la costruzione della classe Args, la quale, data in input una stringa di formattazione e degli argomenti, e poi possibile interrogarla chiedendole il valore degli argomenti.

ArgumentMarshaler

<?php

interface ArgumentMarshaler
{
    /**
     * @param ArgumentMarshaler $am
     * @return mixed
     */
    public static function getValue(ArgumentMarshaler $am);

    /**
     * @param mixed $currentArgument
     * @return void
     */
    public function set($currentArgument): void;
}

BooleanArgumentMarshaler

<?php
include_once('ArgumentMarshaler.php');

class BooleanArgumentMarshaler implements ArgumentMarshaler
{
    /** @var bool */
    private $value = false;

    /**
     * @param ArgumentMarshaler $am
     * @return bool
     */
    public static function getValue(ArgumentMarshaler $am)
    {
        if ($am instanceof BooleanArgumentMarshaler) {
            return $am->value;
        }

        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function set($currentArgument): void
    {
        $this->value = true;
    }
}

FloatArgumentMarshaler

<?php
include_once('ArgumentMarshaler.php');

class FloatArgumentMarshaler implements ArgumentMarshaler
{
    public const SYMBOL = '##';

    /** @var float */
    private $value = 0.0;

    /**
     * @param ArgumentMarshaler $am
     * @return float
     */
    public static function getValue(ArgumentMarshaler $am)
    {
        if ($am instanceof FloatArgumentMarshaler) {
            return $am->value;
        }

        return 0.0;
    }

    /**
     * {@inheritDoc}
     */
    public function set($currentArgument): void
    {
        $this->value = (float)$currentArgument;
    }
}

IntegerArgumentMarshaler

<?php
include_once('ArgumentMarshaler.php');

class IntegerArgumentMarshaler implements ArgumentMarshaler
{
    public const SYMBOL = '#';

    /** @var int */
    private $value = 0;

    /**
     * @param ArgumentMarshaler $am
     * @return int
     */
    public static function getValue(ArgumentMarshaler $am)
    {
        if ($am instanceof IntegerArgumentMarshaler) {
            return $am->value;
        }

        return 0;
    }

    /**
     * {@inheritDoc}
     */
    public function set($currentArgument): void
    {
        $this->value = (int)$currentArgument;
    }
}

StringArgumentMarshaler

<?php
include_once('ArgumentMarshaler.php');

class StringArgumentMarshaler implements ArgumentMarshaler
{
    public const SYMBOL = '*';

    /** @var string */
    private $value = '';

    /**
     * @param ArgumentMarshaler $am
     * @return string
     */
    public static function getValue(ArgumentMarshaler $am)
    {
        if ($am instanceof StringArgumentMarshaler) {
            return $am->value;
        }

        return '';
    }

    /**
     * {@inheritDoc}
     */
    public function set($currentArgument): void
    {
        $this->value = (string)$currentArgument;
    }
}

ArgumentMarshalerCollection

<?php
include_once('ArgsException.php');
include_once('ArgumentMarshaler.php');

class ArgumentMarshalerCollection
{
    /** @var array */
    private $array = [];

    /**
     * @param string $elementId
     * @return ArgumentMarshaler
     * @throws ArgsException
     */
    public function get(string $elementId): ArgumentMarshaler
    {
        if (!isset($this->array[$elementId])) {
            throw new ArgsException(ArgsException::UNEXPECTED_ARGUMENT, $elementId);
        }

        return $this->array[$elementId];
    }

    /**
     * @param string $elementId
     * @param ArgumentMarshaler $am
     * @return void
     */
    public function put(string $elementId, ArgumentMarshaler $am): void
    {
        $this->array[$elementId] = $am;
    }
}

ArgsException

<?php

class ArgsException extends Exception
{
    public const INVALID_ARGUMENT_FORMAT = 1;
    public const UNEXPECTED_ARGUMENT = 2;
    public const INVALID_ARGUMENT_NAME = 3;

    /** @var string|null */
    private $argumentId;

    /** @var string|null */
    private $parameter;

    /**
     * ArgsException constructor.
     * @param int $code
     * @param string|null $argumentId
     * @param string|null $parameter
     */
    public function __construct(int $code, string $argumentId = null, string $parameter = null)
    {
        $this->code = $code;
        $this->argumentId = $argumentId;
        $this->parameter = $parameter;
        parent::__construct($this->formatErrorMessage(), $code);
    }

    /**
     * @return string|null
     */
    public function getArgumentId(): ?string
    {
        return $this->argumentId;
    }

    /**
     * @return string|null
     */
    public function getParameter(): ?string
    {
        return $this->parameter;
    }

    /**
     * @return string
     */
    private function formatErrorMessage(): string
    {
        switch ($this->code) {
            case self::INVALID_ARGUMENT_FORMAT:
                return sprintf('`%s` is not a valid argument format.', $this->parameter);
            case self::UNEXPECTED_ARGUMENT:
                return sprintf('Argument -%s unexpected.', $this->argumentId);
            case self::INVALID_ARGUMENT_NAME:
                return sprintf('`%s` is not a valid argument name.', $this->argumentId);
            default:
                return 'TILT: Should not get here.';
        }
    }
}

Args

<?php
include_once('ArgsException.php');
include_once('ArgumentMarshaler/ArgumentMarshalerCollection.php');
include_once('ArgumentMarshaler/BooleanArgumentMarshaler.php');
include_once('ArgumentMarshaler/FloatArgumentMarshaler.php');
include_once('ArgumentMarshaler/IntegerArgumentMarshaler.php');
include_once('ArgumentMarshaler/StringArgumentMarshaler.php');

class Args
{
    private const SCHEMA_SEPARATOR = ',';

    /** @var ArgumentMarshalerCollection */
    private $marshalers;

    /** @var string[] */
    private $args = [];

    /** @var string[] */
    private $argsFound = [];

    /**
     * Args constructor.
     * @param string $schema
     * @param string[] $args
     * @throws ArgsException
     */
    public function __construct(string $schema, array $args)
    {
        $this->marshalers = new ArgumentMarshalerCollection();
        $this->args = $args;
        $this->parseSchema($schema);
        $this->parseArgumentStrings();
    }

    /**
     * @param string $schema
     * @return void
     * @throws ArgsException
     */
    private function parseSchema(string $schema): void
    {
        $elements = explode(self::SCHEMA_SEPARATOR, $schema);
        foreach ($elements as $element) {
            if (strlen($element) > 0) {
                $this->parseSchemaElement(trim($element));
            }
        }
    }

    /**
     * @param string $element
     * @return void
     * @throws ArgsException
     */
    private function parseSchemaElement(string $element): void
    {
        $elementId = $element[0];
        $elementTail = substr($element, 1);
        $this->validateSchemaElementId($elementId);
        if (strlen($elementTail) === 0) {
            $this->marshalers->put($elementId, new BooleanArgumentMarshaler());
        } elseif ($elementTail === StringArgumentMarshaler::SYMBOL) {
            $this->marshalers->put($elementId, new StringArgumentMarshaler());
        } elseif ($elementTail === IntegerArgumentMarshaler::SYMBOL) {
            $this->marshalers->put($elementId, new IntegerArgumentMarshaler());
        } elseif ($elementTail === FloatArgumentMarshaler::SYMBOL) {
            $this->marshalers->put($elementId, new FloatArgumentMarshaler());
        } else {
            throw new ArgsException(ArgsException::INVALID_ARGUMENT_FORMAT, $elementId, $elementTail);
        }
    }

    /**
     * @param string $elementId
     * @return void
     * @throws ArgsException
     */
    private function validateSchemaElementId(string $elementId): void
    {
        if (!ctype_alpha($elementId)) {
            throw new ArgsException(ArgsException::INVALID_ARGUMENT_NAME, $elementId);
        }
    }

    /**
     * @return void
     * @throws ArgsException
     */
    private function parseArgumentStrings(): void
    {
        foreach ($this->args as $arg) {
            if (substr($arg, 0, 1) === '-') {
                $this->parseArgumentCharacters(substr($arg, 1));
            }
        }
    }

    /**
     * @param string $argChars
     * @return void
     * @throws ArgsException
     */
    private function parseArgumentCharacters(string $argChars): void
    {
        for ($i = 0; $i < strlen($argChars); $i++) {
            $this->parseArgumentCharacter($argChars[$i]);
        }
    }

    /**
     * @param string $argChar
     * @return void
     * @throws ArgsException
     */
    private function parseArgumentCharacter(string $argChar): void
    {
        $am = $this->marshalers->get($argChar);
        $am->set(next($this->args));
        $this->argsFound[] = $argChar;
    }

    /**
     * @param string $arg
     * @return bool
     */
    public function has(string $arg): bool
    {
        return in_array($arg, $this->argsFound);
    }

    /**
     * @param string $arg
     * @return bool
     * @throws ArgsException
     */
    public function getBoolean(string $arg): bool
    {
        return BooleanArgumentMarshaler::getValue($this->marshalers->get($arg));
    }

    /**
     * @param string $arg
     * @return string
     * @throws ArgsException
     */
    public function getString(string $arg): string
    {
        return StringArgumentMarshaler::getValue($this->marshalers->get($arg));
    }

    /**
     * @param string $arg
     * @return int
     * @throws ArgsException
     */
    public function getInteger(string $arg): int
    {
        return IntegerArgumentMarshaler::getValue($this->marshalers->get($arg));
    }

    /**
     * @param string $arg
     * @return float
     * @throws ArgsException
     */
    public function getFloat(string $arg): float
    {
        return FloatArgumentMarshaler::getValue($this->marshalers->get($arg));
    }
}

Index

<?php
include_once('Args.php');

try {
    $args = new Args('l,p#,d*,x##', ['-lpdx', true, 42, 'param', 16.5]);

    var_dump($args->getBoolean('l'));
    var_dump($args->getInteger('p'));
    var_dump($args->getString('d'));
    var_dump($args->getFloat('x'));
} catch (ArgsException $e) {
    var_dump($e->getMessage());
}