PierInfor\Undercover\Parser

Complexity

Total Complexity

14

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Test Coverage

Coverage

94.87%

Importance

Changes	2
Bugs	1	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getParser()	0	3	1
A	getResults()	0	3	1
A	setContent()	0	8	2
A	exists()	0	4	1
A	init()	0	4	1
A	getArgs()	0	3	1
A	parse()	0	20	5
A	getContent()	0	3	1

<?php

declare(strict_types=1);

namespace PierInfor\Undercover;

use PierInfor\Undercover\Interfaces\IParser;
use PierInfor\Undercover\Interfaces\IArgs;
use PierInfor\Undercover\Args;
use PierInfor\Undercover\Interfaces\IProcessor;
use PierInfor\Undercover\Processor;

/**
 * Parser is a clover coverage parser
 *
 * @author Pierre Fromager <info@pier_infor.fr>
 * @version 1.0
 * @package PierInfor\Undercover
 */
class Parser implements IParser
{

    /**
     * $args
     *
     * @var IArgs
     */
    protected $args;

    /**
     * $content
     *
     * @var string
     */
    protected $content;

    /**
     * processor
     *
     * @var IProcessor
     */
    protected $processor;

    /**
     * constructor
     */
    public function __construct()
    {
        $this->args = new Args();
        $this->processor = new Processor();
        $this->init();
    }

    /**
     * initializer
     *
     * @return IParser
     */
    protected function init(): IParser
    {
        $this->setContent();
        return $this;
    }

    /**
     * parse xml clover file and set coverage results
     *
     * @return IParser
     */
    public function parse(): IParser
    {
        if (!empty($this->getContent())) {
            $xml = new \SimpleXMLElement(
                $this->getContent()
            );
            $metrics = $xml->project->metrics;
            $classes = $xml->xpath(self::XPATH_SEARCH);
            $coveredClasses = 0;
            foreach ($classes as $class) {
                $methods = (int) $class->metrics[Args::_METHODS];
                $areMethodsCovered = ($methods > 0
                    && $methods === (int) $class->metrics[IProcessor::COVERED_METHODS]);
                if ($areMethodsCovered) {
                    $coveredClasses++;
                }
            }
            $this->processor->process($coveredClasses, $metrics);
        }
        return $this;
    }

    /**
     * return parser instance
     *
     * @return IParser
     */
    public function getParser(): IParser
    {
        return $this;
    }

    /**
     * return Args object
     *
     * @return IArgs
     */
    public function getArgs(): IArgs
    {
        return $this->args;
    }

    /**
     * returns result metrics coverage ratios as array
     *
     * @return array
     */
    public function getResults(): array
    {
        return $this->processor->getResults();
    }

    /**
     * returns coverage file content
     *
     * @return string
     */
    protected function getContent(): string
    {
        return $this->content;
    }

    /**
     * set content from file
     *
     * @return IParser
     */
    protected function setContent(): IParser
    {
        $this->content = ($this->exists())
            ? file_get_contents(
                $this->args->getFilename()
            )
            : '';
        return $this;
    }

    /**
     * returns true if file exists
     *
     * @return boolean
     */
    protected function exists(): bool
    {
        return file_exists(
            $this->args->getFilename()
        );
    }
}