PSFS\base\extension\TemplateFunctions

Complexity

Total Complexity

34

Size/Duplication

Total Lines	229
Duplicated Lines	4.37 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	3
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	asset()	0	12	4
A	route()	0	9	2
A	config()	0	3	2
A	button()	0	5	1
B	widget()	0	14	5
A	form()	0	5	1
A	resource()	0	7	1
B	extractPathname()	10	16	5
A	processCssLines()	0	10	3
A	putResourceContent()	0	6	2
B	processAsset()	0	18	5
A	session()	0	3	1
A	existsFlash()	0	3	1
A	getFlash()	0	5	1

<?php
    namespace PSFS\base\extension;

    use PSFS\base\config\Config;
    use PSFS\base\exception\ConfigException;
    use PSFS\base\Request;
    use PSFS\base\Router;
    use PSFS\base\Security;
    use PSFS\base\Template;
    use PSFS\base\types\Form;
    use PSFS\Services\GeneratorService;
    use Symfony\Component\Translation\Tests\StringClass;

    class TemplateFunctions {

        const ASSETS_FUNCTION       = "\\PSFS\\base\\extension\\TemplateFunctions::asset";
        const ROUTE_FUNCTION        = "\\PSFS\\base\\extension\\TemplateFunctions::route";
        const CONFIG_FUNCTION       = "\\PSFS\\base\\extension\\TemplateFunctions::config";
        const BUTTON_FUNCTION       = "\\PSFS\\base\\extension\\TemplateFunctions::button";
        const WIDGET_FUNCTION       = "\\PSFS\\base\\extension\\TemplateFunctions::widget";
        const FORM_FUNCTION         = "\\PSFS\\base\\extension\\TemplateFunctions::form";
        const RESOURCE_FUNCTION     = "\\PSFS\\base\\extension\\TemplateFunctions::resource";
        const SESSION_FUNCTION      = "\\PSFS\\base\\extension\\TemplateFunctions::session";
        const EXISTS_FLASH_FUNCTION = "\\PSFS\\base\\extension\\TemplateFunctions::existsFlash";
        const GET_FLASH_FUNCTION    = "\\PSFS\\base\\extension\\TemplateFunctions::getFlash";

        /**
         * Función que copia los recursos de las carpetas Public al DocumentRoot
         * @param $string
         * @param null $name
         * @param bool|TRUE $return
         *
         * @return string
         */
        public static function asset($string, $name = null, $return = true) {

            $file_path = "";
            if (!file_exists($file_path)) {
                $file_path = BASE_DIR.$string;
            }
            $filename_path = AssetsParser::findDomainPath($string, $file_path);

            $file_path = self::processAsset($string, $name, $return, $filename_path);
            $return_path = (empty($name)) ? Request::getInstance()->getRootUrl().'/'.$file_path : $name;
            return ($return) ? $return_path : '';
        }

        /**
         * Función que devuelve una url correspondiente a una ruta
         * @param string $path
         * @param bool|FALSE $absolute
         * @param array $params

Should the type for parameter $params not be null|array? Also, consider making the array more specific, something like array<String>, or String[].

         *
         * @return string|null
         */
        public static function route($path = '', $absolute = false, array $params = null) {
            $router = Router::getInstance();
            try {
                return $router->getRoute($path, $absolute, $params);
            } catch (\Exception $e)
            {
                return $router->getRoute('', $absolute, $params);
            }
        }

        /**
         * Función que devuelve un parámetro de la configuración
         * @param $param
         * @param string $default
         *
         * @return string
         */
        public static function config($param, $default = '') {
            return Config::getInstance()->get($param) ?: $default;
        }

        /**
         * Método que devuelve un botón en html para la plantilla de formularios
         * @param array $button
         */
        public static function button(array $button) {
            Template::getInstance()->getTemplateEngine()->display('forms/button.html.twig', array(
                'button' => $button,
            ));
        }

        /**
         * Función que pinta parte de un formulario
         * @param array $field
         * @param StringClass $label
         */
        public static function widget(array $field, StringClass $label = null) {
            if (!empty($label)) {
                $field["label"] = $label;
            }
            //Limpiamos los campos obligatorios
            if (!isset($field["required"])) {
                $field["required"] = true;
            } elseif (isset($field["required"]) && (bool)$field["required"] === false) {
                unset($field["required"]);
            }
            Template::getInstance()->getTemplateEngine()->display('forms/field.html.twig', array(
                'field' => $field,
            ));
        }

        /**
         * Función que deveulve un formulario en html
         * @param Form $form
         */
        public static function form(Form $form) {
            Template::getInstance()->getTemplateEngine()->display('forms/base.html.twig', array(
                'form' => $form,
            ));
        }

        /**
         * Función que copia un recurso directamente en el DocumentRoot
         * @param string $path
         * @param string $dest
         * @param bool|FALSE $force
         *
         * @return string
         * @throws ConfigException
         */
        public static function resource($path, $dest, $force = false) {
            $debug = Config::getInstance()->getDebugMode();
            $domains = Template::getDomains(true);
            $filename_path = self::extractPathname($path, $domains);
            GeneratorService::copyResources($dest, $force, $filename_path, $debug);
            return '';
        }

        /**
         * Método que extrae el pathname para un dominio
         * @param string $path
         * @param $domains
         *
         * @return mixed

Consider making the return type a bit more specific; maybe use string.

         */
        private static function extractPathname($path, $domains)
        {
            $filename_path = $path;
            if (!file_exists($path) && !empty($domains)) {
                foreach ($domains as $domain => $paths) {
                    $domain_filename = str_replace($domain, $paths["public"], $path);
                    if (file_exists($domain_filename)) {
                        $filename_path = $domain_filename;
                        continue;
                    }
                }

            }

            return $filename_path;
        }

        /**
         * @param string $filename_path
         */
        private static function processCssLines($filename_path)
        {
            $handle = @fopen($filename_path, 'r');
            if ($handle) {
                while (!feof($handle)) {
                    AssetsParser::extractCssLineResource($handle, $filename_path);
                }
                fclose($handle);
            }
        }

        /**
         * Método que copia el contenido de un recurso en su destino correspondiente
         * @param string $name
         * @param string $filename_path
         * @param string $base
         * @param string $file_path
         */
        private static function putResourceContent($name, $filename_path, $base, $file_path)
        {
            $data = file_get_contents($filename_path);
            if (!empty($name)) file_put_contents(WEB_DIR.DIRECTORY_SEPARATOR.$name, $data);
            else file_put_contents($base.$file_path, $data);
        }

        /**
         * Método que procesa un recurso para su copia en el DocumentRoot
         * @param string $string
         * @param string $name
         * @param boolean $return
         * @param string $filename_path
         *
         * @return string
         */
        private static function processAsset($string, $name, $return, $filename_path)
        {
            $file_path = $filename_path;
            if (file_exists($filename_path)) {
                list($base, $html_base, $file_path) = AssetsParser::calculateAssetPath($string, $name, $return, $filename_path);

This line exceeds maximum limit of 120 characters; contains 128 characters

                //Creamos el directorio si no existe
                Config::createDir($base.$html_base);
                //Si se ha modificado
                if (!file_exists($base.$file_path) || filemtime($base.$file_path) < filemtime($filename_path)) {
                    if ($html_base == 'css') {
                        self::processCssLines($filename_path);
                    }
                    self::putResourceContent($name, $filename_path, $base, $file_path);
                }
            }

            return $file_path;
        }

        /**
         * Template function for get a session var
         * @param string $key
         * @return mixed
         */
        public static function session($key) {
            return Security::getInstance()->getSessionKey($key);
        }

        /**
         * Template function that check if exists any flash session var
         * @param string $key
         * @return bool
         */
        public static function existsFlash($key = '') {
            return null !== Security::getInstance()->getFlash($key);
        }

        /**
         * Template function that get a flash session var
         * @param string $key
         * @return mixed
         */
        public static function getFlash($key) {
            $var = Security::getInstance()->getFlash($key);
            Security::getInstance()->setFlash($key, null);
            return $var;
        }
    }