Element - Code Metrics - webino/Webino - Measure and Improve Code Quality continuously with Scrutinizer

Element A
last analyzed 2017-12-02 21:12 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	195
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
dl	0
loc	195
rs	10
c	0
b	0
f	0
wmc	28
lcom	1
cbo	7

11 Methods

Rating	Name	Size	Complexity
A	locate()	5	1
A	setValue()	5	1
A	setAttribute()	10	2
A	getInnerHtml()	9	3
A	getOuterHtml()	4	1
B	isEmpty()	17	5
A	rename()	17	3
A	remove()	5	1
A	normalizeHtml()	4	1
B	setHtml()	25	5
B	replace()	29	5

<?php

namespace WebinoDomLib\Dom;

use WebinoBaseLib\Util\ToString;
use WebinoDomLib\Dom;
use WebinoHtmlLib\Html\EscaperAwareTrait;

/**
 * Class Element
 */
class Element extends \DOMElement implements
    NodeInterface,
    NodeLocatorInterface
{
    use EscaperAwareTrait;
    use LocatorAwareTrait;

    /**
     * Return an element collection
     *
     * @param string|array $locator
     * @return NodeList
     */
    public function locate($locator)
    {
        $nodeList = $this->getLocator()->query($this, $locator);
        return new NodeList($nodeList);
    }

    /**
     * @param string $value Node value.
     * @return $this
     */
    public function setValue($value)
    {
        $this->nodeValue = $this->getEscaper()->escapeHtml($value);
        return $this;
    }

    /**
     * @param string $name
     * @param string $value
     * @return $this
     */
    public function setAttribute($name, $value)
    {
        if (empty($value)) {
            $this->removeAttribute($name);
            return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        parent::setAttribute($name, htmlspecialchars($value, ENT_QUOTES));
        return $this;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @param string|array $html Valid XHTML code.
     * @return $this
     */
    public function setHtml($html)
    {
        $html = $this->normalizeHtml($html);
        if (empty($html)) {
            return $this;
        }

        $this->nodeValue = '';
        $frag = $this->ownerDocument->createDocumentFragment();
        $frag->appendXml($html);

        // TODO refactor
        if ($frag->firstChild) {
            $this->appendChild($frag);
        } else {
            /** @var Element $node */
            foreach ((new Dom($html))->locate('body') as $node) {
                foreach ($node->childNodes as $child) {
                    $this->appendChild($this->ownerDocument->importNode($child, true));
                }
            }
        }

        return $this;
    }

    /**
     * Returns the node body html
     *
     * @return string
     */
    public function getInnerHtml()
    {
        $html = '';
        foreach ($this->childNodes as $child) {
            $childHtml = $child->ownerDocument->saveXML($child);
            empty($childHtml) or $html .= $childHtml;
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
        }
        return $html;
    }

    /**
     * Returns the node html
     *
     * @return string
     */
    public function getOuterHtml()
    {
        return trim($this->ownerDocument->saveXML($this));
    }

    /**
     * @return bool
     */
    public function isEmpty()
    {
        $nodeValue = trim($this->nodeValue);
        if (!empty($nodeValue) || is_numeric($nodeValue)) {
            return false;
        }

        // node value is empty,
        // check for child other than text
        foreach ($this->childNodes as $childNode) {
            if (!($childNode instanceof \DOMText)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param string $nodeName New node name.
     * @return $this
     */
    public function rename($nodeName)
    {
        /** @var self $node */
        $node = $this->ownerDocument->createElement($nodeName);

        $html = $this->getInnerHtml();
        $html and $node->setHtml($html);
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

        foreach ($this->attributes as $attrib) {
            $node->setAttributeNode($attrib);
        }

        $this->parentNode->insertBefore($node, $this);
        $this->remove();

        return $node;
    }

    /**
     * @param string|array $html
     * @return $this
     */
    public function replace($html)
    {
        $html = $this->normalizeHtml($html);
        if (empty($html)) {
            $this->remove();
            return $this;
        }

        $frag = $this->ownerDocument->createDocumentFragment();
        $frag->appendXML($html);

        // TODO refactor
        if ($frag->firstChild) {
            $node = $this->parentNode->insertBefore($frag, $this);
        } else {
            $nodes = [];
            /** @var Element $node */
            foreach ((new Dom($html))->locate('body') as $subNode) {
                foreach ($subNode->childNodes as $child) {
                    // TODO add node to node list
                    $nodes[] = $this->parentNode->insertBefore($this->ownerDocument->importNode($child, true), $this);
                }
            }
            $node = new NodeList($nodes);
        }

        $this->remove();
        return $node;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @return $this
     */
    public function remove()
    {
        $this->parentNode->removeChild($this);
        return $this;
    }

    /**
     * @param string|array $html
     * @return string
     */
    private function normalizeHtml($html)
    {
        return ToString::value($html);
    }
}


Element A
last analyzed 2017-12-02 21:12 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

webino / Webino

Element A last analyzed 2017-12-02 21:12 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

11 Methods

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Element A
last analyzed 2017-12-02 21:12 UTC