Ffcms\Core\Helper\HTML\System\NativeGenerator

Complexity

Total Complexity

34

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	1
Bugs	0	Features	0

9 Methods

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

<?php

namespace Ffcms\Core\Helper\HTML\System;

use Ffcms\Core\App;
use Ffcms\Core\Helper\Security;
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)
    {
        $data = App::$Security->secureHtml($data);
        return $quotes ? $data : App::$Security->escapeQuotes($data);
    }

    /**
     * Remove all html tags from data
     * @param string $data
     * @return string
     */
    public static function nohtml($data)
    {
        return App::$Security->escapeQuotes(App::$Security->strip_tags($data));

It seems like \Ffcms\Core\App::$Security->strip_tags($data) targeting Ffcms\Core\Helper\Security::strip_tags() 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) {
                $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
     * @return string
     */
    public static function buildSingleTag($tagName, array $property = null)
    {
        return '<' . self::nohtml($tagName) . self::applyProperty($property) . '/>';
    }

    /**
     * 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 = urlencode($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);
                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 (null !== $elementArray[2]) {
                    $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)) {
                        $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 188 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 188 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 188 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 188 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 188 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;
    }


}