Element::isEmpty() - Code Metrics - webino/Webino - Measure and Improve Code Quality continuously with Scrutinizer

Element::isEmpty() B
last analyzed 2017-12-02 21:12 UTC

↳ Parent: Element

Complexity

Conditions	5
Paths	4

Size

Total Lines	17
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	8
nc	4
nop	0
dl	0
loc	17
rs	8.8571
c	0
b	0
f	0

<?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::isEmpty() B
last analyzed 2017-12-02 21:12 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

webino / Webino

Element::isEmpty() B last analyzed 2017-12-02 21:12 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Element::isEmpty() B
last analyzed 2017-12-02 21:12 UTC