SimpleEntityGeneratorBundle\Lib\Tools

Complexity

Total Complexity

34

Size/Duplication

Total Lines	217
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
D	isNamespaceValid()	0	31	9
B	isValidPropertyNameString()	0	24	6
A	isValidPropertyTypeString()	0	15	3
A	getNamespaceWithoutName()	0	7	1
A	getDirectoryFromNamespace()	0	5	1
A	getNameFromNamespace()	0	6	1
A	removeBackslashPrefixFromNamespace()	0	8	2
A	checkNamespaceValid()	0	6	2
A	explodeTemplateStringToArray()	0	8	2
A	implodeArrayToTemplate()	0	8	2
A	isCallableConstraintAnnotation()	0	14	3
A	isFirstCharBackslash()	0	8	2

<?php

namespace SimpleEntityGeneratorBundle\Lib;

use Exception;
use JMS\Serializer\TypeParser;

/**
 * Tools
 *
 * @author Sławomir Kania <slawomir.kania1@gmail.com>
 */
class Tools
{

    /**
     * @param string $namespace
     * @param string $mandatoryFirstBackslash
     * @return boolean
     */
    public static function isNamespaceValid($namespace, $mandatoryFirstBackslash = true)
    {
        if ($mandatoryFirstBackslash && false == self::isFirstCharBackslash($namespace)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        if (1 !== preg_match("/[\\\\]{1,1}/", $namespace)) {
            return false;
        }

        if (1 === preg_match("/[\\\\]{2,}/", $namespace)) {
            return false;
        }

        if (1 === preg_match('/[^a-zA-Z0-9\\\\\\_]+/', $namespace)) {
            return false;
        }

        $namespaceElementsArray = explode("\\", $namespace);
        if (count($namespaceElementsArray) < 3) {
            return false;
        }

        foreach ($namespaceElementsArray as $element) {
            if (ctype_digit(substr($element, 0, 1))) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param string $name
     * @return boolean
     */
    public static function isValidPropertyNameString($name)
    {
        if (false == is_string($name)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        if (empty($name)) {
            return false;
        }

        if ("_" == $name) {
            return false;
        }

        if (1 === preg_match('/[^a-zA-Z0-9\_]+/', $name)) {
            return false;
        }

        if (ctype_digit(substr($name, 0, 1))) {
            return false;
        }

        return true;
    }

    /**
     * @param string $type
     * @return boolean
     */
    public static function isValidPropertyTypeString($type)
    {
        if (false == is_string($type)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        try {
            $jmsTypeParser = new TypeParser();
            $jmsTypeParser->parse($type);
        } catch (Exception $ex) {
            return false;
        }

        return true;
    }

    /**
     * @param string $namespace
     * @return string
     * @throws Exception
     */
    public static function getNamespaceWithoutName($namespace)
    {
        self::checkNamespaceValid($namespace);
        $parts = explode('\\', $namespace);
        unset($parts[count($parts) - 1]);
        return implode("\\", $parts);
    }

    /**
     * @param string $namespace
     * @return string
     * @throws Exception
     */
    public static function getDirectoryFromNamespace($namespace)
    {
        self::checkNamespaceValid($namespace);
        return str_replace("\\", "/", self::getNamespaceWithoutName($namespace));
    }

    /**
     * @param string $namespace
     * @return string
     * @throws Exception
     */
    public static function getNameFromNamespace($namespace)
    {
        self::checkNamespaceValid($namespace);
        $parts = explode('\\', $namespace);
        return $parts[count($parts) - 1];
    }

    /**
     * @param string $namespace
     * @return string
     */
    public static function removeBackslashPrefixFromNamespace($namespace)
    {
        self::checkNamespaceValid($namespace);
        if ("\\" == substr($namespace, 0, 1)) {
            return substr($namespace, 1);
        }
        return $namespace;
    }

    /**
     * Throw Exception when namespace invalid
     *
     * @param string $namespace
     * @throws Exception
     */
    public static function checkNamespaceValid($namespace)
    {
        if (false == self::isNamespaceValid($namespace)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            throw new Exception(sprintf("Invalid namespace: %s", $namespace));
        }
    }

    /**
     * @param string $string
     * @return array
     * @throws Exception
     */
    public static function explodeTemplateStringToArray($string)
    {
        if (false == is_string($string)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            throw new Exception("Param has to be string!");
        }

        return preg_split("/\n/", $string);
    }

    /**
     * @param array $array
     * @return string
     * @throws Exception
     */
    public static function implodeArrayToTemplate($array)
    {
        if (false == is_array($array)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            throw new Exception("Invalid array!");
        }

        return implode("\n", $array);
    }

    /**
     * Check existance of constraint
     * proper annotation eg. @\Symfony\Component\Validator\Constraints\Valid()
     *
     * @param string $constraintAnnotation
     * @return boolean
     */
    public static function isCallableConstraintAnnotation($constraintAnnotation)
    {
        $output = [];
        preg_match("/\@(.*?)\(.*?\)/", $constraintAnnotation, $output);

        if ($output < 2) {
            return false;
        }
        if (false == class_exists(end($output))) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return false;
        }

        return true;
    }

    /**
     * If first character of string is backslash then return true
     *
     * @param string $string
     * @return boolean
     * @throws Exception
     */
    public static function isFirstCharBackslash($string)
    {
        if (false == is_string($string)) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            throw new Exception("Invalid string!");
        }

        return "\\" == substr((string) $string, 0, 1);
    }
}