Vikpe\HtmlHeadingNormalizer

Complexity

Total Complexity

26

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	3
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	demote()	0	4	1
A	promote()	0	4	1
A	normalizeHeadings()	0	13	2
A	replaceHeadings()	0	6	2
A	containsHeadings()	0	7	1
A	tagNameToLevel()	0	4	1
A	levelToTagName()	0	4	1
A	normalize()	0	22	3
A	getHeadings()	0	13	3
A	cloneHeading()	0	10	1
A	copyAttributes()	0	6	2
A	moveChildNodes()	0	7	2
A	formatResult()	0	17	3
A	containsDocType()	0	4	1
A	stringContains()	0	4	1
A	containsHtmlTag()	0	4	1

<?php

namespace Vikpe;

class HtmlHeadingNormalizer
{
    public static function demote($html, $levels)
    {
        return self::normalize($html, $levels);
    }

    public static function promote($html, $levels)
    {
        return self::normalize($html, -$levels);
    }

    private static function normalize($html, $levels)
    {
        $normalizationIsRequired = ((abs($levels) > 0) && self::containsHeadings($html));

        if (!$normalizationIsRequired) {
            return $html;
        }

        $domDocument = new \DOMDocument();
        $domDocument->loadHTML($html);

        $originalHeadings = self::getHeadings($domDocument);
        $normalizedHeadings = self::normalizeHeadings($originalHeadings, $levels);

        self::replaceHeadings(
            $originalHeadings,
            $normalizedHeadings
        );

        return $domDocument->saveHTML();
        return self::formatResult($domDocument, $html);

return self::formatResult($domDocument, $html); does not seem to be reachable.

    }

    private static function getHeadings(\DOMDocument $domDocument)
    {
        $tagNames = array('h1', 'h2', 'h3', 'h4', 'h5', 'h6');
        $headings = array();

        foreach ($tagNames as $tagName) {
            foreach ($domDocument->getElementsByTagName($tagName) as $heading) {
                $headings[] = $heading;
            }
        }

        return $headings;
    }

    private static function normalizeHeadings(array $originalHeadings, $levelDelta)
    {
        $normalizedHeadings = array();

        foreach ($originalHeadings as $heading) {
            $currentLevel = self::tagNameToLevel($heading->tagName);
            $newLevel = $currentLevel + $levelDelta;

            $normalizedHeadings[] = self::cloneHeading($heading, $newLevel);
        }

        return $normalizedHeadings;
    }

    private static function replaceHeadings(array $needles, array $replacements)
    {
        foreach ($needles as $i => $needle) {
            $needle->parentNode->replaceChild($replacements[$i], $needle);
        }
    }

    private static function containsHeadings($html)
    {
        $headingNeedle = '<h';
        $containsHeadings = (false !== stripos($html, $headingNeedle));

        return $containsHeadings;
    }

    private static function tagNameToLevel($tagName)
    {
        return substr($tagName, 1);
    }

    private static function levelToTagName($level)
    {
        return 'h'.$level;
    }

    private static function cloneHeading(\DOMElement $sourceHeading, $newLevel)
    {
        $tagName = self::levelToTagName($newLevel);

        $targetHeading = $sourceHeading->parentNode->ownerDocument->createElement($tagName);
        self::copyAttributes($sourceHeading, $targetHeading);
        self::moveChildNodes($sourceHeading, $targetHeading);

        return $targetHeading;
    }

    private static function copyAttributes(\DOMElement $source, \DOMElement $target)
    {
        foreach ($source->attributes as $attribute) {
            $target->setAttribute($attribute->name, $attribute->value);
        }
    }

    private static function moveChildNodes(\DOMElement $source, \DOMElement $target)
    {
        while ($source->hasChildNodes()) {
            // appendChild() actually moves the childNode
            $target->appendChild($source->childNodes->item(0));
        }
    }

    private static function formatResult(\DOMDocument $domDocument, $originalHtml)
    {
        if (!self::containsDocType($originalHtml)) {
            $domDocument->removeChild($domDocument->doctype);
        }

        if (self::containsHtmlTag($originalHtml)) {
            return $domDocument->saveHTML();
        } else {
            $bodyDomElement = $domDocument->getElementsByTagName('body')
                                          ->item(0);

            $html = $domDocument->saveHTML($bodyDomElement);

            return str_replace(['<body>', '</body>'], '', $html);
        }
    }

    private static function containsDocType($html)
    {
        return self::stringContains($html, '<!DOCTYPE');
    }

    private static function stringContains($string, $needle)
    {
        return (false !== strpos($string, $needle));
    }

    private static function containsHtmlTag($html)
    {
        return self::stringContains($html, '<html');
    }
}