Dallgoot\Yaml\Loader

Complexity

Total Complexity

35

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	17	6
A	__construct()	0	6	4
C	parse()	0	54	16
B	onSpecialType()	0	16	7
A	onDeepestType()	0	26	2

<?php
declare(strict_types=1);

Missing file doc comment

namespace Dallgoot\Yaml;

use Dallgoot\Yaml as Y;

final class Loader

Missing class doc comment

{
    //public
    public $errors = [];

    public const EXCLUDE_DIRECTIVES = 1;//DONT include_directive
    public const IGNORE_COMMENTS    = 2;//DONT include_comments
    public const NO_PARSING_EXCEPTIONS = 4;//THROW Exception on parsing Errors
    public const NO_OBJECT_FOR_DATE = 8;//DONT import date strings as dateTime Object
    //privates
    private $content;/* @var null|string */

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

    private $filePath;/* @var null|string */

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

    private $debug = 0;//TODO: determine levels

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

    private $options = 0;/* @var int */

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

    //Exceptions messages
    private const INVALID_VALUE        = self::class.": at line %d";
    private const EXCEPTION_NO_FILE    = self::class.": file '%s' does not exists (or path is incorrect?)";
    private const EXCEPTION_READ_ERROR = self::class.": file '%s' failed to be loaded (permission denied ?)";
    private const EXCEPTION_LINE_SPLIT = self::class.": content is not a string(maybe a file error?)";

    public function __construct($absolutePath = null, $options = null, $debug = 0)

Missing function doc comment

    {
        $this->debug   = is_int($debug)   ? min($debug, 3) : 1;
        $this->options = is_int($options) ? $options       : $this->options;
        if (is_string($absolutePath)) {
            $this->load($absolutePath);
        }
    }

    /**
     * load a file and save its content as $content

Doc comment short description must start with a capital letter

     *
     * @param      string       $absolutePath  The absolute path of a file

Expected 1 spaces after parameter type; 7 found

Expected 1 spaces after parameter name; 2 found

Tag value indented incorrectly; expected 1 spaces but found 6

     *
     * @throws     \Exception   if file don't exist OR reading failed

Tag value indented incorrectly; expected 1 spaces but found 5

     *
     * @return     self  ( returns the same Loader  )

Tag value indented incorrectly; expected 1 spaces but found 5

     */
    public function load(string $absolutePath):Loader
    {
        $this->debug > 1 && var_dump($absolutePath);

var_dump($absolutePath) looks like debug code. Are you sure you do not want to remove it?

        $this->filePath = $absolutePath;
        if (!file_exists($absolutePath)) {
            throw new \Exception(sprintf(self::EXCEPTION_NO_FILE, $absolutePath));
        }
        $adle = "auto_detect_line_endings";
        $prevADLE = ini_get($adle);
        !$prevADLE && ini_set($adle, "true");
        $content = file($absolutePath, FILE_IGNORE_NEW_LINES);
        !$prevADLE && ini_set($adle, "false");
        if (is_bool($content)) {
            throw new \Exception(sprintf(self::EXCEPTION_READ_ERROR, $absolutePath));
        }
        $this->content = $content;
        return $this;
    }

    /**
     * Parse Yaml lines into an hierarchy of Node
     *
     * @param      string       $strContent  The Yaml string or null to parse loaded content

Expected 1 spaces after parameter type; 7 found

Expected 1 spaces after parameter name; 2 found

Tag value indented incorrectly; expected 2 spaces but found 6

     * @throws     \Exception    if content is not available as $strContent or as $this->content (from file)

Tag cannot be grouped with parameter tags in a doc comment

Tag value indented incorrectly; expected 1 spaces but found 5

     * @throws     \ParseError  if any error during parsing or building

Tag cannot be grouped with parameter tags in a doc comment

Tag value indented incorrectly; expected 1 spaces but found 5

     *
     * @return     array|YamlObject      the hierarchy built an array of YamlObject or just YamlObject

Tag value indented incorrectly; expected 1 spaces but found 5

     */
    public function parse($strContent = null)
    {
        $source = $this->content;
        if (is_null($source)) $source = preg_split("/([^\n\r]+)/um", $strContent, 0, PREG_SPLIT_DELIM_CAPTURE);

Inline control structures are discouraged

        //TODO : be more permissive on $strContent values
        if (!is_array($source)) throw new \Exception(self::EXCEPTION_LINE_SPLIT);

Inline control structures are discouraged

        $previous = $root = new Node();
        $emptyLines = [];
        $specialTypes = Y\LITTERALS | Y\BLANK;

The constant Dallgoot\Yaml\Y\BLANK was not found. Maybe you did not declare it correctly or list all dependencies?

        try {
            foreach ($source as $lineNb => $lineString) {
                $n = new Node($lineString, $lineNb + 1);//TODO: useful???-> $this->debug && var_dump($n);
                $deepest = $previous->getDeepestNode();
                if ($deepest->type & Y\PARTIAL) {

The constant Dallgoot\Yaml\Y\PARTIAL was not found. Maybe you did not declare it correctly or list all dependencies?

                    //TODO:verify this edge case
                    // if ($n->type === Y\KEY && $n->indent === $previous->indent) {
                    //     throw new \ParseError(sprintf(self::INVALID_VALUE, $lineNb), 1);
                    // }
                    $deepest->parse($deepest->value.' '.ltrim($lineString));
                } else {
                    if (($n->type & $specialTypes) && $this->onSpecialType($n, $previous, $emptyLines)) {
                        continue;
                    }
                    if ($n->type & Y\SCALAR) {

The constant Dallgoot\Yaml\Y\SCALAR was not found. Maybe you did not declare it correctly or list all dependencies?

                        foreach ($emptyLines as $blankNode) {
                            $blankNode->getParent()->add($blankNode);
                        }
                    }
                    $emptyLines = [];
                    switch ($n->indent <=> $previous->indent) {
                        case -1: $previous->getParent($n->indent)->add($n);break;

Line indented incorrectly; expected 20 spaces, found 24

Closing brace must be on a line by itself

                        case  0: $previous->getParent()->add($n);break;

Line indented incorrectly; expected 20 spaces, found 24

Closing brace must be on a line by itself

                        default:

Line indented incorrectly; expected 20 spaces, found 24

                            if ($this->onDeepestType($n, $previous, $lineString)) continue 2;

Inline control structures are discouraged

                            $previous->add($n);
                    }
                    $previous = $n;
                }
            }
            if ($this->debug === 2) {

The condition $this->debug is always false. If $this->debug can have other possible types, add them to yaml/Loader.php:19

                var_dump("\033[33mParsed Structure\033[0m\n", $root);

var_dump('Parsed Structure ', $root) looks like debug code. Are you sure you do not want to remove it?

                die("Debug of root structure requested (remove debug level to suppress these)");

Using exit here is not recommended.

            }
            $out = Builder::buildContent($root, $this->debug);//var_dump($out);exit();

$this->debug of type null|string is incompatible with the type integer expected by parameter $_debug of Dallgoot\Yaml\Builder::buildContent().

            return $out;
        } catch (\Error|\Exception|\ParseError $e) {
            $file = basename($this->filePath);
            $message = basename($e->getFile())."@".$e->getLine().":".$e->getMessage()." in '$file' @".($lineNb+1)."\n";

The variable $lineNb seems to be defined by a foreach iteration on line 84. Are you sure the iterator is never empty, otherwise this variable is not defined?

            if ($e instanceof \ParseError && ($this->options & self::NO_PARSING_EXCEPTIONS)) {
                trigger_error($message, E_USER_WARNING);
                $this->errors[] = $message;
                var_dump($root);
            }
            throw new \Exception($message, 3);
        }
    }

    private function onSpecialType(&$n, &$previous, &$emptyLines):bool

Private method name "Loader::onSpecialType" must be prefixed with an underscore

Missing function doc comment

    {
        $deepest = $previous->getDeepestNode();
        if ($n->type & Y\LITTERALS) {
            if ($deepest->type & Y\KEY && is_null($deepest->value)) {

The constant Dallgoot\Yaml\Y\KEY was not found. Maybe you did not declare it correctly or list all dependencies?

                $deepest->add($n);
                $previous = $n;
                return true;
            }
        }
        if ($n->type & Y\BLANK) {

The constant Dallgoot\Yaml\Y\BLANK was not found. Maybe you did not declare it correctly or list all dependencies?

            if ($previous->type & Y\SCALAR) $emptyLines[] = $n->setParent($previous->getParent());

The constant Dallgoot\Yaml\Y\SCALAR was not found. Maybe you did not declare it correctly or list all dependencies?

Inline control structures are discouraged

            if ($deepest->type & Y\LITTERALS) $emptyLines[] = $n->setParent($deepest);

Inline control structures are discouraged

            return true;
        }
        return false;
    }

    private function onDeepestType(&$n, &$previous, $lineString):bool

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

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

Private method name "Loader::onDeepestType" must be prefixed with an underscore

Missing function doc comment

    {
        $deepest = $previous->getDeepestNode();
        // if ($deepest->type & Y\LITTERALS) {
        //     $n->value = trim($lineString);//fall through
        // }
        // if ($deepest->type & (Y\LITTERALS | Y\REF_DEF | Y\SET_VALUE | Y\TAG) && is_null($deepest->value)) {
        //     $parent = $deepest;
        // }
        // // if ($previous->type & Y\ITEM && $n->type & Y\KEY) {
        // //     $previous
        // // }
        if ($deepest->type & (Y\BLANK | Y\SCALAR) ) {//|| ($previous->type & (Y\ITEM | Y\SET_KEY))) {

The constant Dallgoot\Yaml\Y\SCALAR was not found. Maybe you did not declare it correctly or list all dependencies?

The constant Dallgoot\Yaml\Y\BLANK was not found. Maybe you did not declare it correctly or list all dependencies?

                $previous = $deepest->getParent();
        //     // if ($n->type === Y\SCALAR && ($deepest->getParent()->type & Y\LITTERALS)) {

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     // $deepest->type = Y\SCALAR;

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     // $deepest->value .= "\n".$n->value;

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     // ->add($n);

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     // return true;

Line indented incorrectly; expected at least 12 spaces, found 8

        //     // } else {

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     if ($previous->type & (Y\ITEM | Y\SET_KEY)) {

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //         $parent = $deepest->getParent();

Line indented incorrectly; expected at least 12 spaces, found 8

        //     //     }

Line indented incorrectly; expected at least 12 spaces, found 8

        //     // }

Line indented incorrectly; expected at least 12 spaces, found 8

        }
        return false;
    }
}