DumperHandlers::dumpCompound() - Code Metrics - Inspection of "simplification of DumperHandlers : dumpCompound &..." - dallgoot/yaml - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d81ab2...154df5 )

by stéphane

created 2019-06-03 15:04 UTC

DumperHandlers::dumpCompound() A

↳ Parent: DumperHandlers

Complexity

Conditions	5
Paths	4

Size

Total Lines	14
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	5.0187

Importance

Changes

Metric	Value
cc	5
eloc	10
nc	4
nop	2
dl	0
loc	14
ccs	10
cts	11
cp	0.9091
crap	5.0187
rs	9.6111
c	0
b	0
f	0

<?php
namespace Dallgoot\Yaml;

// use \SplDoublyLinkedList as DLL;

/**
 *  Convert PHP datatypes to a YAML string syntax
 *
 * @author  Stéphane Rebai <[email protected]>
 * @license Apache 2.0
 * @link    https://github.com/dallgoot/yaml
 */
class DumperHandlers
{
    private const INDENT = 2;
    private const OPTIONS = 00000;
    private const DATE_FORMAT = 'Y-m-d';

    private $options;
    private $multipleDocs = false;
    //options
    public const EXPAND_SHORT = 00001;
    public const SERIALIZE_CUSTOM_OBJECTS = 00010;
    public $floatPrecision = 4;

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



    public function dump($dataType, int $indent):string
    {
        if(is_null($dataType)) {
            return '';
        } elseif(is_resource($dataType)) {
            return get_resource_type($dataType);
        } elseif (is_scalar($dataType)) {
            return $this->dumpScalar($dataType);
        } else {
            return $this->dumpCompound($dataType, $indent);
        }
    }

    public function dumpScalar($dataType):string
    {
        if ($dataType === \INF) return '.inf';
        if ($dataType === -\INF) return '-.inf';
        $precision = "%.".$this->floatPrecision."F";
        switch (gettype($dataType)) {
            case 'boolean': return $dataType ? 'true' : 'false';
            case 'float': //fall through
            case 'double': return is_nan((double) $dataType) ? '.nan' : sprintf($precision, $dataType);
        }
        return $this->dumpString($dataType);
    }


    private function dumpCompound($compound, int $indent):string
    {
        if (is_array($compound)) {
            $iterator = new \ArrayIterator($compound);
            $mask = '-';
            $refKeys = range(0, count($compound)-1);
            if (array_keys($compound) !== $refKeys) {
                $mask = '%s:';
            }
            return $this->iteratorToString($iterator, $mask, $indent);
        } elseif (is_object($compound) && !is_callable($compound)) {
            return $this->dumpObject($compound, $indent);
        }
        throw new \Exception("Dumping Callable|Resource is not currently supported", 1);
    }

    private function dumpObject(object $object, int $indent):string
    {
        if ($object instanceof YamlObject) {
            return $this->dumpYamlObject($object);
        } elseif ($object instanceof Compact) {
            return $this->dumpCompact($object, $indent);
        } elseif ($object instanceof Tagged) {
            return $this->dumpTagged($object, $indent);
        } elseif ($object instanceof \DateTime) {
            return $object->format(self::DATE_FORMAT);
        } elseif (is_iterable($object)) {
            $iterator = $object;
        } else {
            $iterator = new \ArrayIterator(get_object_vars($object));
        }
        return $this->iteratorToString($iterator, '%s:', $indent);
    }


    private function dumpYamlObject(YamlObject $obj):string
    {
        if ($this->multipleDocs || $obj->hasDocStart() || $obj->isTagged()) {
        if ($this->multipleDocs || $obj->hasDocStart() || $obj->/** @scrutinizer ignore-call */ isTagged()) {
           $this->multipleDocs = true;
          // && $this->$result instanceof DLL) $this->$result->push("---");
        }
        if (count($obj) > 0) {
            return $this->iteratorToString($obj, '-', 0);
        }
        return $this->iteratorToString(new \ArrayIterator(get_object_vars($obj)), '%s:', 0);
        // $this->insertComments($obj->getComment());
        //TODO: $references = $obj->getAllReferences();
    }


    private function iteratorToString(\Iterator $iterable, string $keyMask, int $indent):string
    {
        $pairs = [];
        foreach ($iterable as $key => $value) {
            $separator = "\n";
            $valueIndent = $indent + self::INDENT;
            if (is_scalar($value) || $value instanceof Compact || $value instanceof \DateTime ) {
                $separator   = ' ';
                $valueIndent = 0;
            }
            $pairs[] = str_repeat(' ', $indent).sprintf($keyMask, $key).$separator.$this->dump($value, $valueIndent);
        }
        return implode("\n", $pairs);
    }

    /**
     * Dumps a Compact|mixed (representing an array or object) as the single-line format representation.
     * All values inside are assumed single-line as well.
     * Note: can NOT use JSON_encode because of possible reference calls or definitions as : '&abc 123', '*fre'
     * which would be quoted by json_encode
     *
     * @param mixed   $subject The subject
     * @param integer $indent  The indent
     *
     * @return string the string representation (JSON like) of the value
     */
    public function dumpCompact($subject, int $indent):string
    {
        $structureFormat = '{%s}';
        $keyFormat = "%s: ";
        if (!is_array($subject) && !($subject instanceof \ArrayIterator)) {
            $source = get_object_vars($subject);
        } else {
            $max = count($subject);
            $objectAsArray = is_array($subject) ? $subject : $subject->getArrayCopy();
            $source = $objectAsArray;
            if(array_keys($objectAsArray) === range(0, $max-1)) {
                $structureFormat = '[%s]';
                $keyFormat = '';
            }
        }
        $content = [];
        foreach ($source as $key => $value) {
            $content[] = sprintf($keyFormat, $key).(is_scalar($value) ? $this->dump($value, $indent) : $this->dumpCompact($value, $indent));
        }
        return sprintf($structureFormat, implode(', ', $content));
    }

    /**
     * Dumps a string. Protects it if needed
     *
     * @param      string  $str    The string
     *
     * @return     string  ( description_of_the_return_value )
     * @todo   implements checking and protection function
     */
    public function dumpString(string $str):string
    {
        return ltrim($str);
    }

    public function dumpTagged(Tagged $obj, int $indent):string
    {
        $separator   = ' ';
        $valueIndent = 0;
        if (!is_scalar($obj->value)) {
            $separator = "\n";
            $valueIndent = $indent + self::INDENT;
        }
        return $obj->tagName.$separator.$this->dump($obj->value, $valueIndent);
    }
}


dallgoot / yaml

Push — master ( d81ab2...154df5 )

DumperHandlers::dumpCompound() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like