StatusValue.php

Go to the documentation of this file.

<?php
use MediaWiki\Message\Converter;
use Wikimedia\Message\MessageValue;
 
class StatusValue {
 
    protected $ok = true;
 
    protected $errors = [];
 
    public $value;
 
    public $success = [];
 
    public $successCount = 0;
 
    public $failCount = 0;
 
    public static function newFatal( $message, ...$parameters ) {
        $result = new static();
        $result->fatal( $message, ...$parameters );
        return $result;
    }
 
    public static function newGood( $value = null ) {
        $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 ) {
        if ( $newError[ 'message' ] instanceof MessageSpecifier ) {
            $isEqual = static function ( $existingError ) use ( $newError ) {
                if ( $existingError['message'] instanceof MessageSpecifier ) {
                    // compare attributes of both MessageSpecifiers
                    return $newError['message'] == $existingError['message'];
                } else {
                    return $newError['message']->getKey() === $existingError['message'] &&
                        $newError['message']->getParams() === $existingError['params'];
                }
            };
        } else {
            $isEqual = static function ( $existingError ) use ( $newError ) {
                if ( $existingError['message'] instanceof MessageSpecifier ) {
                    return $newError['message'] === $existingError['message']->getKey() &&
                        $newError['params'] === $existingError['message']->getParams();
                } else {
                    return $newError['message'] === $existingError['message'] &&
                        $newError['params'] === $existingError['params'];
                }
            };
        }
        foreach ( $this->errors as $index => $existingError ) {
            if ( $isEqual( $existingError ) ) {
                if ( $newError[ 'type' ] === 'error' && $existingError[ 'type' ] === 'warning' ) {
                    $this->errors[ $index ][ 'type' ] = 'error';
                }
                return $this;
            }
        }
        $this->errors[] = $newError;
        return $this;
    }
 
    public function warning( $message, ...$parameters ) {
        $message = $this->normalizeMessage( $message, $parameters );
 
        return $this->addError( [
            'type' => 'warning',
            'message' => $message,
            'params' => $parameters
        ] );
    }
 
    public function error( $message, ...$parameters ) {
        $message = $this->normalizeMessage( $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 ) {
        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 hasMessage( $message ) {
        if ( $message instanceof MessageSpecifier ) {
            $message = $message->getKey();
        } elseif ( $message instanceof MessageValue ) {
            $message = $message->getKey();
        }
 
        foreach ( $this->errors as $error ) {
            if ( $error['message'] instanceof MessageSpecifier
                && $error['message']->getKey() === $message
            ) {
                return true;
            } elseif ( $error['message'] === $message ) {
                return true;
            }
        }
 
        return false;
    }
 
    public function replaceMessage( $source, $dest ) {
        $replaced = false;
 
        $source = $this->normalizeMessage( $source );
        $dest = $this->normalizeMessage( $dest );
 
        foreach ( $this->errors as $index => $error ) {
            if ( $error['message'] === $source ) {
                $this->errors[$index]['message'] = $dest;
                $replaced = true;
            } elseif ( $error['message'] instanceof MessageSpecifier
                && $error['message']->getKey() === $source ) {
                $this->errors[$index]['message'] = $dest;
                $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 ( isset( $this->value ) ) {
            $valstr = gettype( $this->value ) . " value set";
            if ( is_object( $this->value ) ) {
                $valstr .= "\"" . get_class( $this->value ) . "\" instance";
            }
        } else {
            $valstr = "no value set";
        }
        $out = sprintf( "<%s, %s, %s>",
            $status,
            $errorcount,
            $valstr
        );
        if ( count( $this->errors ) > 0 ) {
            $hdr = sprintf( "+-%'-8s-+-%'-25s-+-%'-36s-+\n", "", "", "" );
            $i = 1;
            $out .= "\n";
            $out .= $hdr;
            foreach ( $this->errors as $error ) {
                if ( $error['message'] instanceof MessageSpecifier ) {
                    $key = $error['message']->getKey();
                    $params = $error['message']->getParams();
                } elseif ( $error['params'] ) {
                    $key = $error['message'];
                    $params = $error['params'];
                } else {
                    $key = $error['message'];
                    $params = [];
                }
 
                $type = $error['type'];
                $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
                    );
                }
 
                $i++;
            }
            $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() ) . ' }';
            } 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 === false || $error['type'] === $type ) {
                if ( $error['message'] instanceof MessageSpecifier ) {
                    $result[] = array_merge(
                        [ $error['message']->getKey() ],
                        $error['message']->getParams()
                    );
                } elseif ( $error['params'] ) {
                    $result[] = array_merge( [ $error['message'] ], $error['params'] );
                } else {
                    $result[] = [ $error['message'] ];
                }
            }
        }
 
        return $result;
    }
 
    private function normalizeMessage( $message, array $parameters = [] ) {
        if ( $message instanceof MessageValue ) {
            $converter = new Converter();
            return $converter->convertMessageValue( $message );
        }
 
        return $message;
    }
}