dallgoot / yaml

Dumper.php

<?php
namespace Dallgoot\Yaml;

use Dallgoot\Yaml\{Types as T, YamlObject, Tag, Compact};
use \SplDoublyLinkedList as DLL;

/**
 *
 */
class Dumper //extends AnotherClass
{
    private const indent = 2;
    private const width = 160;
    private const options = 00000;

    private static $result;
    //options
    public const EXPAND_SHORT = 00001;
    public const SERIALIZE_CUSTOM_OBJECTS = 00010;

    public function __construct(int $options = null)
    {
        if (!is_null($options)) {
            $this->options = $options;

The property options does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }
    }

    public static function toString($dataType, int $options):string
    {
        if (is_null($dataType)) {
            throw new \Exception(self::class.": No content to convert to Yaml", 1);
        }
        $options = is_null($options) ? self::options : $options;

The condition is_null($options) is always false.

The assignment to $options is dead and can be removed.

        self::$result = new DLL;
        self::$result->setIteratorMode(DLL::IT_MODE_FIFO | DLL::IT_MODE_DELETE);
        if ($dataType instanceof YamlObject) {
            return self::dumpYamlObject($dataType);

The expression return self::dumpYamlObject($dataType) returns the type null which is incompatible with the type-hinted return string.

Are you sure the usage of self::dumpYamlObject($dataType) targeting Dallgoot\Yaml\Dumper::dumpYamlObject() seems to always return null.

        } elseif (is_array($dataType) && $dataType[0] instanceof YamlObject) {
            array_map([self::class, 'dumpYamlObject'], $dataType);
        } else {
            self::dump($dataType, 0);
        }
        return implode("\n", self::$result);

self::result of type SplDoublyLinkedList is incompatible with the type array expected by parameter $pieces of implode().

    }

    public static function toFile(string $file, $dataType, int $options):bool
    {
        return !is_bool(file_put_contents($file, self::toString($dataType, $options)));
    }

    private static function dump($dataType, int $indent)
    {
        if (is_object($dataType)) {
            if ($dataType instanceof Tag) {
                foreach (self::split("!".$dataType->tagName.' '.$dataType->value, $indent) as $chunks) {

Are you sure $dataType->value of type null|string|Dallgoot\Yaml\Node can be used in concatenation?

                    self::$result->push($chunks);
                }
            }
            if ($dataType instanceof Compact) {
                self::dumpCompact($dataType, $indent);
            }
            if ($dataType instanceof \DateTime) {
                # code...
            }
        } elseif (is_array($dataType)) {
            self::dumpSequence($dataType, $indent);
        }
    }

    private static function dumpYamlObject(YamlObject $dataType)
    {
        self::dump($dataType, 0);
        self::insertComments($dataType->getComment());

The method getComment() does not exist on Dallgoot\Yaml\YamlObject. Since you implemented __call, consider adding a @method annotation.

        //TODO: $references = $dataType->getAllReferences();
    }

    private static function split($string, $indent):array
    {
        return str_split(str_pad($string, $indent, " ", STR_PAD_LEFT), self::width);
    }

    private static function dumpSequence(array $array, int $indent):void
    {
        $refKeys = range(0, count($array));
        foreach ($array as $key => $item) {
            $lineStart = current($refKeys) === $key ? "- " : "- $key: ";
            $value     = self::dump($item, $indent + self::indent);

Are you sure the assignment to $value is correct as self::dump($item, $indent + self::indent) targeting Dallgoot\Yaml\Dumper::dump() seems to always return null.

            if (is_null($value)) {
                self::$result->push(self::split($lineStart, $indent + self::indent)[0]);
            } else {
                foreach (self::split($lineStart.$value, $indent + self::indent) as $chunks) {
                    self::$result->push($chunks);
                }
            }
            next($refKeys);
        }
    }

    private static function insertComments($commentsArray):void
    {
        foreach ($commentsArray as $lineNb => $comment) {
            self::$result->add($lineNb, $comment);
        }
    }

    public static function dumpCompact($dataType, int $indent)

The parameter $dataType is not used and could be removed.

The parameter $indent is not used and could be removed.

    {
        # code...
    }
}