Tools::isFirstCharBackslash() - Code Metrics - Inspection of "Daily Inspection: Merge pull request #8 from komik..." - slawomirkania/class-generator-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (3b8125)

unknown

created 2021-02-25 14:50 UTC

Tools::isFirstCharBackslash() A

↳ Parent: Tools

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

namespace HelloWordPl\SimpleEntityGeneratorBundle\Lib;

use Exception;
use JMS\Serializer\TypeParser;

/**
 * Tools
 *
 * @author Sławomir Kania <[email protected]>
 */
class Tools
{

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

            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)) {

            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)) {

            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)) {

            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)) {

            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)) {

            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))) {

            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)) {

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

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


1			<?php
2
3			namespace HelloWordPl\SimpleEntityGeneratorBundle\Lib;
4
5			use Exception;
6			use JMS\Serializer\TypeParser;
7
8			/**
9			* Tools
10			*
11			* @author Sławomir Kania <[email protected]>
12			*/
13			class Tools
14			{
15
16			/**
17			* @param string $namespace
18			* @param string $mandatoryFirstBackslash
19			* @return boolean
20			*/
21			public static function isNamespaceValid($namespace, $mandatoryFirstBackslash = true)
22			{
23			if ($mandatoryFirstBackslash && false == self::isFirstCharBackslash($namespace)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
24			return false;
25			}
26
27			if (1 !== preg_match("/[\\\\]{1,1}/", $namespace)) {
28			return false;
29			}
30
31			if (1 === preg_match("/[\\\\]{2,}/", $namespace)) {
32			return false;
33			}
34
35			if (1 === preg_match('/[^a-zA-Z0-9\\\\\\_]+/', $namespace)) {
36			return false;
37			}
38
39			$namespaceElementsArray = explode("\\", $namespace);
40			if (count($namespaceElementsArray) < 3) {
41			return false;
42			}
43
44			foreach ($namespaceElementsArray as $element) {
45			if (ctype_digit(substr($element, 0, 1))) {
46			return false;
47			}
48			}
49
50			return true;
51			}
52
53			/**
54			* @param string $name
55			* @return boolean
56			*/
57			public static function isValidPropertyNameString($name)
58			{
59			if (false == is_string($name)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
60			return false;
61			}
62
63			if (empty($name)) {
64			return false;
65			}
66
67			if ("_" == $name) {
68			return false;
69			}
70
71			if (1 === preg_match('/[^a-zA-Z0-9\_]+/', $name)) {
72			return false;
73			}
74
75			if (ctype_digit(substr($name, 0, 1))) {
76			return false;
77			}
78
79			return true;
80			}
81
82			/**
83			* @param string $type
84			* @return boolean
85			*/
86			public static function isValidPropertyTypeString($type)
87			{
88			if (false == is_string($type)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
89			return false;
90			}
91
92			try {
93			$jmsTypeParser = new TypeParser();
94			$jmsTypeParser->parse($type);
95			} catch (Exception $ex) {
96			return false;
97			}
98
99			return true;
100			}
101
102			/**
103			* @param string $namespace
104			* @return string
105			* @throws Exception
106			*/
107			public static function getNamespaceWithoutName($namespace)
108			{
109			self::checkNamespaceValid($namespace);
110			$parts = explode('\\', $namespace);
111			unset($parts[count($parts) - 1]);
112			return implode("\\", $parts);
113			}
114
115			/**
116			* @param string $namespace
117			* @return string
118			* @throws Exception
119			*/
120			public static function getDirectoryFromNamespace($namespace)
121			{
122			self::checkNamespaceValid($namespace);
123			return str_replace("\\", "/", self::getNamespaceWithoutName($namespace));
124			}
125
126			/**
127			* @param string $namespace
128			* @return string
129			* @throws Exception
130			*/
131			public static function getNameFromNamespace($namespace)
132			{
133			self::checkNamespaceValid($namespace);
134			$parts = explode('\\', $namespace);
135			return $parts[count($parts) - 1];
136			}
137
138			/**
139			* @param string $namespace
140			* @return string
141			*/
142			public static function removeBackslashPrefixFromNamespace($namespace)
143			{
144			self::checkNamespaceValid($namespace);
145			if ("\\" == substr($namespace, 0, 1)) {
146			return substr($namespace, 1);
147			}
148			return $namespace;
149			}
150
151			/**
152			* Throw Exception when namespace invalid
153			*
154			* @param string $namespace
155			* @throws Exception
156			*/
157			public static function checkNamespaceValid($namespace)
158			{
159			if (false == self::isNamespaceValid($namespace)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
160			throw new Exception(sprintf("Invalid namespace: %s", $namespace));
161			}
162			}
163
164			/**
165			* @param string $string
166			* @return array
167			* @throws Exception
168			*/
169			public static function explodeTemplateStringToArray($string)
170			{
171			if (false == is_string($string)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
172			throw new Exception("Param has to be string!");
173			}
174
175			return preg_split("/\n/", $string);
176			}
177
178			/**
179			* @param array $array
180			* @return string
181			* @throws Exception
182			*/
183			public static function implodeArrayToTemplate($array)
184			{
185			if (false == is_array($array)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
186			throw new Exception("Invalid array!");
187			}
188
189			return implode("\n", $array);
190			}
191
192			/**
193			* Check existance of constraint
194			* proper annotation eg. @\Symfony\Component\Validator\Constraints\Valid()
195			*
196			* @param string $constraintAnnotation
197			* @return boolean
198			*/
199			public static function isCallableConstraintAnnotation($constraintAnnotation)
200			{
201			$output = [];
202			preg_match("/\@(.?)\(.?\)/", $constraintAnnotation, $output);
203
204			if ($output < 2) {
205			return false;
206			}
207			if (false == class_exists(end($output))) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
208			return false;
209			}
210
211			return true;
212			}
213
214			/**
215			* If first character of string is backslash then return true
216			*
217			* @param string $string
218			* @return boolean
219			* @throws Exception
220			*/
221			public static function isFirstCharBackslash($string)
222			{
223			if (false == is_string($string)) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-12-23 15:06 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
224			throw new Exception("Invalid string!");
225			}
226
227			return "\\" == substr((string) $string, 0, 1);
228			}
229			}
230

slawomirkania / class-generator-bundle

Branch — master (3b8125)

Tools::isFirstCharBackslash() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like