Ffcms\Core\Helper\HTML\System\NativeGenerator

Complexity

Total Complexity

40

Size/Duplication

Total Lines	232
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	safe()	0	21	3
A	nohtml()	0	5	2
B	applyProperty()	0	16	7
A	buildSingleTag()	0	4	2
A	buildContainerTag()	0	9	2
A	safeUri()	0	9	2
C	isCurrentLink()	0	59	14
A	applyEscape()	0	11	3
A	convertLink()	0	14	4
A	encode()	0	6	1

<?php

namespace Ffcms\Core\Helper\HTML\System;

use Ffcms\Core\App;
use Ffcms\Core\Helper\Type\Obj;
use Ffcms\Core\Helper\Type\Str;
use Ffcms\Core\Helper\Url;

abstract class NativeGenerator
{

    /**
     * Make data "safe" - all dangerous html/js/etc will be removed
     * @param string $data
     * @param bool $quotes
     * @return string
     */
    public static function safe($data, $quotes = false)
    {
        $purifier = null;

$purifier is not used, you could remove the assignment.

        if (App::$Memory->get('object.purifier.helpers') !== null) {
            $purifier = App::$Memory->get('object.purifier.helpers');
        } else {
            $config = \HTMLPurifier_Config::createDefault();
            $config->set('Cache.SerializerPath', root . '/Private/Cache/HTMLPurifier/');
            $config->set('AutoFormat.AutoParagraph', false);

            // allow use target=_blank for links
            $def = $config->getHTMLDefinition(true);
            $def->addAttribute('a', 'target', 'Enum#_blank,_self,_target,_top');

            $purifier = new \HTMLPurifier($config);
            App::$Memory->set('object.purifier.helpers', $purifier);
        }

        $data = $purifier->purify($data);
        return $quotes ? $data : App::$Security->escapeQuotes($data);
    }

    /**
     * Remove all html tags from data
     * @param string $data
     * @param bool $quotes
     * @return string
     */
    public static function nohtml($data, $quotes = false)
    {
        $plaintext = App::$Security->strip_tags($data);
        return $quotes === true ? $plaintext : App::$Security->escapeQuotes($plaintext);

It seems like $plaintext defined by \Ffcms\Core\App::$Security->strip_tags($data) on line 49 can also be of type array; however, Ffcms\Core\Helper\Security::escapeQuotes() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * Build property for html element from array.
     * IMPORTANT: $property can be null-string (some times this happend's) - do not remove NULL!!
     * @param array $property
     * @return null|string
     */
    public static function applyProperty(array $property = null)
    {
        if (!Obj::isArray($property) || count($property) < 1) {
            return null;
        }
        
        $build = null;
        foreach ($property as $p => $v) {

The expression $property of type null|array is not guaranteed to be traversable. How about adding an additional type check?

            if ($v === null || $v === false || $v === true) {
                $build .= ' ' . self::nohtml($p);
            } else {
                $build .= ' ' . self::nohtml($p) . '="' . self::nohtml($v) . '"';
            }
        }
        return $build;
    }

    /**
     * Fast building single tag based on property's array
     * @param string $tagName
     * @param array|null $property
     * @param bool $closeSlash
     * @return string
     */
    public static function buildSingleTag($tagName, array $property = null, $closeSlash = true)
    {
        return '<' . self::nohtml($tagName) . self::applyProperty($property) . ($closeSlash ? '/>' : '>');
    }

    /**
     * Fast building container type tag based on property's and value
     * @param string $tagName
     * @param array|null $property
     * @param null|string $value
     * @param bool $valueHtml
     * @return string
     */
    public static function buildContainerTag($tagName, array $property = null, $value = null, $valueHtml = false)
    {
        $tagName = self::nohtml($tagName);
        if ($valueHtml !== true) {
            $value = self::nohtml($value);
        }
        
        return '<' . $tagName . self::applyProperty($property) . '>' . $value . '</' . $tagName . '>';
    }

    /**
     * Make parts of URI safe and usable
     * @param string $string
     * @param bool $encode
     * @return string
     */
    public static function safeUri($string, $encode = true)
    {
        $string = Str::lowerCase($string);
        $string = self::nohtml($string);
        if ($encode === true) {
            $string = self::encode($string);
        }
        return $string;
    }

    /**
     * Check if uri $source is equal to current uri point with array of $aliases and active $order set
     * @param null $source
     * @param array|null $aliases
     * @param bool $order
     * @return bool
     */
    public static function isCurrentLink($source = null, array $aliases = null, $order = false)
    {
        $elementPoint = Url::buildPathway($source);
        $currentPoint = Url::buildPathwayFromRequest();

        // use special active element order type: controller, action
        switch ($order) {
            case 'controller':
                $elementPoint = Str::firstIn($elementPoint, '/');
                $active = Str::startsWith($elementPoint, $currentPoint);

It seems like $elementPoint defined by \Ffcms\Core\Helper\Type\Str::firstIn($elementPoint, '/') on line 137 can also be of type false; however, Ffcms\Core\Helper\Type\Str::startsWith() does only seem to accept string, did you maybe forget to handle an error condition?

                break;
            case 'action':
                $elementArray = explode('/', $elementPoint);
                if (!Str::contains('/', $elementPoint) || count($elementArray) < 2) {
                    $active = $elementPoint === $currentPoint;
                } else {
                    $elementPoint = $elementArray[0] . '/' . $elementArray[1];
                    $active = Str::startsWith($elementPoint, $currentPoint);
                }
                break;
            case 'id':
                $elementArray = explode('/', $elementPoint);
                $elementPoint = $elementArray[0] . '/' . $elementArray[1];
                if ($elementArray[2] === null) { // looks like id is not defined in element
                    if (Str::contains('?', $currentPoint)) {
                        $currentPoint = Str::firstIn($currentPoint, '?');
                    }
                    $currentArray = explode('/', $currentPoint);
                    $currentToId = implode('/', array_slice($currentArray, 0, 3));
                    $active = $elementPoint === $currentToId;
                } else {
                    $elementPoint .= '/' . $elementArray[2];
                    $active = Str::startsWith($elementPoint, $currentPoint);
                }
                break;
            default:
                $active = $elementPoint === $currentPoint;
                break;
        }

        // check if current uri equals with aliases
        if (Obj::isArray($aliases) && count($aliases) > 0) {
            foreach ($aliases as $activeUri) {

The expression $aliases of type null|array is not guaranteed to be traversable. How about adding an additional type check?

                $activeUri = trim($activeUri, '/');
                if (Str::endsWith('*', $activeUri)) {
                    $activeUri = rtrim($activeUri, '*');
                    if (Str::startsWith($activeUri, $currentPoint)) {

It seems like $currentPoint can also be of type false or null; however, Ffcms\Core\Helper\Type\Str::startsWith() does only seem to accept string, maybe add an additional type check?

                        $active = true;
                    }
                } else {
                    if ($activeUri === $currentPoint) {
                        $active = true;
                    }
                }
            }
        }

        return $active;
    }

    /**
     * Apply security for string to output as html
     * @param string|null $object
     * @param bool $html
     * @param bool $secure
     * @return null|string
     */
    public static function applyEscape($object = null, $html = false, $secure = false)
    {
        $object = (string)$object;
        if ($html !== true) {
            $object = self::nohtml($object);
        } elseif ($secure !== true) {
            $object = self::safe($object, true);
        }

        return $object;
    }

    /**
     * Convert link-binding type to classic link with security filter
     * @param string|array $uri
     * @return string
     */
    public static function convertLink($uri)
    {
        $link = App::$Alias->baseUrl . '/';
        if (Obj::isArray($uri)) {
            $link .= Url::buildPathway($uri);

It seems like $uri defined by parameter $uri on line 213 can also be of type string; however, Ffcms\Core\Helper\Url::buildPathway() does only seem to accept null|array, maybe add an additional type check?

        } elseif (Str::startsWith('http', $uri)) {

It seems like $uri defined by parameter $uri on line 213 can also be of type array; however, Ffcms\Core\Helper\Type\Str::startsWith() does only seem to accept string, maybe add an additional type check?

            $link = self::nohtml($uri);

It seems like $uri defined by parameter $uri on line 213 can also be of type array; however, Ffcms\Core\Helper\HTML\System\NativeGenerator::nohtml() does only seem to accept string, maybe add an additional type check?

        } elseif (Str::startsWith('#', $uri)) { // allow pass #part

It seems like $uri defined by parameter $uri on line 213 can also be of type array; however, Ffcms\Core\Helper\Type\Str::startsWith() does only seem to accept string, maybe add an additional type check?

            $link = self::nohtml($uri);

It seems like $uri defined by parameter $uri on line 213 can also be of type array; however, Ffcms\Core\Helper\HTML\System\NativeGenerator::nohtml() does only seem to accept string, maybe add an additional type check?

        } else {
            $link .= self::nohtml(trim($uri, '/'));
        }
        return $link;
    }

    /**
     * Encode safe uri links with slashes
     * @param $uri
     * @return string
     */
    public static function encode($uri)
    {
        return implode('/', array_map(function($v){
            return urlencode($v);
        }, explode('/', $uri)));
    }


}