Vikpe\HtmlHeadingNormalizer

Complexity

Total Complexity

17

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	3
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	normalize()	0	19	2
A	getHeadings()	0	14	3
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	cloneHeading()	0	8	1
A	copyAttributes()	0	6	2
A	moveChildNodes()	0	7	2

<?php

namespace Vikpe;

class HtmlHeadingNormalizer
{
    public static function normalize($html, $baseLevel = 1)
    {
        if (!self::containsHeadings($html)) {
            return $html;
        }

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

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

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

        return $domDocument->saveHTML();
    }

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

        $headings = [];

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

        return $headings;
    }

    private static function normalizeHeadings(array $originalHeadings, $baseLevel)
    {
        $normalizedHeadings = [];

        foreach ($originalHeadings as $heading) {
            $currentLevel = self::tagNameToLevel($heading->tagName);
            $newTagName = self::levelToTagName($baseLevel + $currentLevel - 1);

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

        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)
    {
        $heading_needle = '<h';
        $containsHeadings = (false !== stripos($html, $heading_needle));

        return $containsHeadings;
    }

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

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

    private static function cloneHeading(\DOMElement $sourceHeading, $tagName)
    {
        $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));
        }
    }
}