Dallgoot\Yaml\Dumper

Complexity

Total Complexity

38

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	dumpYamlObject()	0	4	1
A	add()	0	5	2
B	dump()	0	14	11
A	toFile()	0	3	1
B	dumpObject()	0	23	7
A	dumpSequence()	0	12	4
B	toString()	0	19	7
A	__construct()	0	3	2
A	insertComments()	0	4	2
A	dumpCompact()	0	2	1

<?php
namespace Dallgoot\Yaml;

Missing file doc comment

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

This use statement conflicts with another class in this namespace, Dallgoot\Yaml\Compact. Consider defining an alias.

This use statement conflicts with another class in this namespace, Dallgoot\Yaml\Tag. Consider defining an alias.

This use statement conflicts with another class in this namespace, Dallgoot\Yaml\YamlObject. Consider defining an alias.

use \SplDoublyLinkedList as DLL;

/**

Doc comment is empty

 *
 */

Missing @category tag in class comment

Missing @package tag in class comment

Missing @author tag in class comment

Missing @license tag in class comment

Missing @link tag in class comment

class Dumper //extends AnotherClass
{
    private const indent = 2;

This class constant is not uppercase (expected INDENT).

    private const width = 120;

This class constant is not uppercase (expected WIDTH).

    private const options = 00000;

This class constant is not uppercase (expected OPTIONS).

    private static $result;

Private member variable "result" must be prefixed with an underscore

    private static $options;

Private member variable "options" must be prefixed with an underscore

    //options
    public const EXPAND_SHORT = 00001;
    public const SERIALIZE_CUSTOM_OBJECTS = 00010;

    public function __construct(int $options = null)

Missing function doc comment

    {
        if (is_int($options)) self::$options = $options;

Inline control structures are discouraged

    }

    public static function toString($dataType, int $options):string

Missing function doc comment

    {
        if (is_null($dataType)) throw new \Exception(self::class.": No content to convert to Yaml", 1);

Inline control structures are discouraged

        self::$options = is_int($options) ? $options : self::$options;

The condition is_int($options) is always true.

        self::$result = new DLL;
        self::$result->setIteratorMode(DLL::IT_MODE_FIFO | DLL::IT_MODE_DELETE);
        if ($dataType instanceof YamlObject) {
            self::dumpYamlObject($dataType);
        } elseif (is_array($dataType) && $dataType[0] instanceof YamlObject) {
            array_map([self::class, 'dumpYamlObject'], $dataType);
        } else {
            self::dump($dataType, 0);
        }
        $out = '';
        foreach (self::$result as $value) {
            $out .= $value."\n";
        }
        self::$result = null;
        return $out;
    }

    public static function toFile(string $filePath, $dataType, int $options):bool

Missing function doc comment

    {
        return !is_bool(file_put_contents($filePath, self::toString($dataType, $options)));
    }

    private static function dump($dataType, int $indent)

Missing function doc comment

Private method name "Dumper::dump" must be prefixed with an underscore

    {
        if (is_scalar($dataType)) {
            switch (gettype($dataType)) {
                case 'boolean': return $dataType ? 'true' : 'false';break;

break is not strictly necessary here and could be removed.

Line indented incorrectly; expected 12 spaces, found 16

Closing brace must be on a line by itself

                case 'float': if (is_infinite($dataType)) return $dataType > 0 ? '.inf' : '-.inf';

Consider adding a comment if this fall-through is intended.

Line indented incorrectly; expected 12 spaces, found 16

Inline control structures are discouraged

                case 'double': if (is_nan($dataType)) return '.nan';

Consider adding a comment if this fall-through is intended.

Line indented incorrectly; expected 12 spaces, found 16

Inline control structures are discouraged

                default:

Line indented incorrectly; expected 12 spaces, found 16

                    return $dataType;
            }
        } elseif (is_object($dataType)) {
            self::dumpObject($dataType, $indent);

The method Dallgoot\Yaml\Dumper::dumpObject() is not static, but was called statically.

        } elseif (is_array($dataType)) {
            self::dumpSequence($dataType, $indent);
        }
    }

    private static function dumpYamlObject(YamlObject $dataType)

Missing function doc comment

Private method name "Dumper::dumpYamlObject" must be prefixed with an underscore

    {
        self::$result->push("---");
        return self::dump($dataType, 0);

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

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

    private static function add($value, $indent)

Missing function doc comment

Private method name "Dumper::add" must be prefixed with an underscore

    {
        $newVal = str_repeat(" ", $indent).$value;
        foreach (str_split($newVal, self::width) as $chunks) {
            self::$result->push($chunks);
        }
    }

    private static function dumpSequence(array $array, int $indent):void

Missing function doc comment

Private method name "Dumper::dumpSequence" must be prefixed with an underscore

    {
        $refKeys = range(0, count($array));
        foreach ($array as $key => $item) {
            $lineStart = current($refKeys) === $key ? "- " : "- $key: ";
            if (is_scalar($item)) {
                self::add($lineStart.$item, $indent );

Expected 0 spaces before closing bracket; 1 found

            } else {
                self::add($lineStart, $indent );

Expected 0 spaces before closing bracket; 1 found

                self::dump($item, $indent + self::indent);
            }
            next($refKeys);
        }
    }

    private static function insertComments(array $commentsArray):void

The method insertComments() is not used, and could be removed.

Missing function doc comment

Private method name "Dumper::insertComments" must be prefixed with an underscore

    {
        foreach ($commentsArray as $lineNb => $comment) {
            self::$result->add($lineNb, $comment);
        }
    }

    private function dumpObject(object $object, int $indent)

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

Missing function doc comment

Private method name "Dumper::dumpObject" must be prefixed with an underscore

    {
        if ($dataType instanceof Tag) {

The variable $dataType seems to be never defined.

            if (is_scalar($dataType->value)) {
                return "!".$dataType->tagName.' '.$dataType->value;
            } else{

Expected "} else \n"; found " else{\n"

                yield "!".$dataType->tagName;
                self::dump($dataType->value, $indent + self::indent);
            }
        }
        if ($dataType instanceof Compact) {//TODO
            self::dumpCompact($dataType, $indent);
        }
        if ($dataType instanceof \DateTime) {
            # code...

Perl-style comments are not allowed. Use "// Comment." or "/* comment */" instead.

        }
        $propList = get_object_vars($dataType);
        foreach ($propList as $property => $value) {
            if (is_scalar($value)) {
                self::add("$property: ".$value, $indent);
            } else {
                self::add("$property: ", $indent);
                self::dump($value, $indent + self::indent);
            }
        }
    }

    public static function dumpCompact(Compact $object, int $indent)

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

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

Missing function doc comment

    {
        // if (empty($object)) return "{}";
        // if (empty($object)) return "[]";
    }
}