StatusValue.php

Go to the documentation of this file.

<?php
use Wikimedia\Assert\Assert;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\Message\MessageValue;
 
class StatusValue implements Stringable {
 
    protected $ok = true;
 
    protected $errors = [];
 
    public $value;
 
    public $success = [];
 
    public $successCount = 0;
 
    public $failCount = 0;
 
    public $statusData;
 
    public function __construct() {
    }
 
    public static function newFatal( $message, ...$parameters ): static {
        $result = new static();
        $result->fatal( $message, ...$parameters );
        return $result;
    }
 
    public static function newGood( $value = null ): static {
        $result = new static();
        $result->value = $value;
        return $result;
    }
 
    public function splitByErrorType() {
        $errorsOnlyStatusValue = static::newGood();
        $warningsOnlyStatusValue = static::newGood();
        $warningsOnlyStatusValue->setResult( true, $this->getValue() );
        $errorsOnlyStatusValue->setResult( $this->isOK(), $this->getValue() );
 
        foreach ( $this->errors as $item ) {
            if ( $item['type'] === 'warning' ) {
                $warningsOnlyStatusValue->errors[] = $item;
            } else {
                $errorsOnlyStatusValue->errors[] = $item;
            }
        }
 
        return [ $errorsOnlyStatusValue, $warningsOnlyStatusValue ];
    }
 
    public function isGood() {
        return $this->ok && !$this->errors;
    }
 
    public function isOK() {
        return $this->ok;
    }
 
    public function getValue() {
        return $this->value;
    }
 
    public function getErrors() {
        return $this->errors;
    }
 
    public function setOK( $ok ) {
        $this->ok = $ok;
        return $this;
    }
 
    public function setResult( $ok, $value = null ) {
        $this->ok = (bool)$ok;
        $this->value = $value;
        return $this;
    }
 
    private function addError( array $newError ) {
        [ 'type' => $newType, 'message' => $newKey, 'params' => $newParams ] = $newError;
        if ( $newKey instanceof MessageSpecifier ) {
            Assert::parameter( $newParams === [],
                '$parameters', "must be empty when using a MessageSpecifier" );
            $newParams = $newKey->getParams();
            $newKey = $newKey->getKey();
        }
 
        foreach ( $this->errors as [ 'type' => &$type, 'message' => $key, 'params' => $params ] ) {
            if ( $key instanceof MessageSpecifier ) {
                $params = $key->getParams();
                $key = $key->getKey();
            }
 
            // This uses loose equality as we must support equality between MessageParam objects
            // (e.g. ScalarParam), including when they are created separate and not by-ref equal.
            if ( $newKey === $key && $newParams == $params ) {
                if ( $type === 'warning' && $newType === 'error' ) {
                    $type = 'error';
                }
                return $this;
            }
        }
 
        $this->errors[] = $newError;
 
        return $this;
    }
 
    public function warning( $message, ...$parameters ) {
        return $this->addError( [
            'type' => 'warning',
            'message' => $message,
            'params' => $parameters
        ] );
    }
 
    public function error( $message, ...$parameters ) {
        return $this->addError( [
            'type' => 'error',
            'message' => $message,
            'params' => $parameters
        ] );
    }
 
    public function fatal( $message, ...$parameters ) {
        $this->ok = false;
        return $this->error( $message, ...$parameters );
    }
 
    public function merge( $other, $overwriteValue = false ) {
        if ( $this->statusData !== null && $other->statusData !== null ) {
            throw new RuntimeException( "Status cannot be merged, because they both have \$statusData" );
        } else {
            $this->statusData ??= $other->statusData;
        }
 
        foreach ( $other->errors as $error ) {
            $this->addError( $error );
        }
        $this->ok = $this->ok && $other->ok;
        if ( $overwriteValue ) {
            $this->value = $other->value;
        }
        $this->successCount += $other->successCount;
        $this->failCount += $other->failCount;
 
        return $this;
    }
 
    public function getErrorsByType( $type ) {
        $result = [];
        foreach ( $this->errors as $error ) {
            if ( $error['type'] === $type ) {
                $result[] = $error;
            }
        }
 
        return $result;
    }
 
    public function getMessages( ?string $type = null ): array {
        Assert::parameter( $type === null || $type === 'warning' || $type === 'error',
            '$type', "must be null, 'warning', or 'error'" );
        $result = [];
        foreach ( $this->errors as $error ) {
            if ( $type === null || $error['type'] === $type ) {
                [ 'message' => $key, 'params' => $params ] = $error;
                if ( $key instanceof MessageSpecifier ) {
                    $result[] = $key;
                } else {
                    $result[] = new MessageValue( $key, $params );
                }
            }
        }
 
        return $result;
    }
 
    public function hasMessage( string $message ) {
        foreach ( $this->errors as [ 'message' => $key ] ) {
            if ( ( $key instanceof MessageSpecifier && $key->getKey() === $message ) ||
                $key === $message
            ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function hasMessagesExcept( string ...$messages ) {
        foreach ( $this->errors as [ 'message' => $key ] ) {
            if ( $key instanceof MessageSpecifier ) {
                $key = $key->getKey();
            }
            if ( !in_array( $key, $messages, true ) ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function replaceMessage( string $source, $dest ) {
        $replaced = false;
 
        foreach ( $this->errors as [ 'message' => &$message, 'params' => &$params ] ) {
            if ( $message === $source ||
                ( $message instanceof MessageSpecifier && $message->getKey() === $source )
            ) {
                $message = $dest;
                if ( $dest instanceof MessageSpecifier ) {
                    // 'params' will be ignored now, so remove them from the internal array
                    $params = [];
                }
                $replaced = true;
            }
        }
 
        return $replaced;
    }
 
    public function __toString() {
        $status = $this->isOK() ? "OK" : "Error";
        if ( count( $this->errors ) ) {
            $errorcount = "collected " . ( count( $this->errors ) ) . " message(s) on the way";
        } else {
            $errorcount = "no errors detected";
        }
        if ( $this->value !== null ) {
            $valstr = get_debug_type( $this->value ) . " value set";
        } else {
            $valstr = "no value set";
        }
        $out = sprintf( "<%s, %s, %s>",
            $status,
            $errorcount,
            $valstr
        );
        if ( count( $this->errors ) > 0 ) {
            $hdr = sprintf( "+-%'-8s-+-%'-25s-+-%'-36s-+\n", "", "", "" );
            $out .= "\n" . $hdr;
            foreach ( $this->errors as [ 'type' => $type, 'message' => $key, 'params' => $params ] ) {
                if ( $key instanceof MessageSpecifier ) {
                    $params = $key->getParams();
                    $key = $key->getKey();
                }
 
                $keyChunks = mb_str_split( $key, 25 );
                $paramsChunks = mb_str_split( $this->flattenParams( $params, " | " ), 36 );
 
                // array_map(null,...) is like Python's zip()
                foreach ( array_map( null, [ $type ], $keyChunks, $paramsChunks )
                    as [ $typeChunk, $keyChunk, $paramsChunk ]
                ) {
                    $out .= sprintf( "| %-8s | %-25s | %-36s |\n",
                        $typeChunk,
                        $keyChunk,
                        $paramsChunk
                    );
                }
            }
            $out .= $hdr;
        }
 
        return $out;
    }
 
    private function flattenParams( array $params, string $joiner = ', ' ): string {
        $ret = [];
        foreach ( $params as $p ) {
            if ( is_array( $p ) ) {
                $r = '[ ' . self::flattenParams( $p ) . ' ]';
            } elseif ( $p instanceof MessageSpecifier ) {
                $r = '{ ' . $p->getKey() . ': ' . self::flattenParams( $p->getParams() ) . ' }';
            } elseif ( $p instanceof MessageParam ) {
                $r = $p->dump();
            } else {
                $r = (string)$p;
            }
 
            $ret[] = mb_strlen( $r ) > 100 ? mb_substr( $r, 0, 99 ) . "..." : $r;
        }
        return implode( $joiner, $ret );
    }
 
    protected function getStatusArray( $type = false ) {
        $result = [];
 
        foreach ( $this->getErrors() as $error ) {
            if ( !$type || $error['type'] === $type ) {
                if ( $error['message'] instanceof MessageSpecifier ) {
                    $result[] = [ $error['message']->getKey(), ...$error['message']->getParams() ];
                } else {
                    $result[] = [ $error['message'], ...$error['params'] ];
                }
            }
        }
 
        return $result;
    }
}