Php::getMetadata() - Code Metrics - Inspection of "Add features from PHP 8.x" - kadet1090/KeyLighter - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 83eaad...7faa90 )

by Kacper

created 2024-01-13 21:08 UTC

Php::getMetadata() A

↳ Parent: Php

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	5
nc	1
nop	0
dl	0
loc	7
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

/**
 * Highlighter
 *
 * Copyright (C) 2016, Some right reserved.
 *
 * @author Kacper "Kadet" Donat <[email protected]>
 *
 * Contact with author:
 * Xmpp: [email protected]
 * E-mail: [email protected]
 *
 * From Kadet with love.
 */

namespace Kadet\Highlighter\Language;

use Kadet\Highlighter\Matcher\CommentMatcher;
use Kadet\Highlighter\Matcher\DelegateRegexMatcher;
use Kadet\Highlighter\Matcher\RegexMatcher;
use Kadet\Highlighter\Matcher\WordMatcher;
use Kadet\Highlighter\Parser\CloseRule;
use Kadet\Highlighter\Parser\OpenRule;
use Kadet\Highlighter\Parser\Rule;
use Kadet\Highlighter\Parser\Token\LanguageToken;
use Kadet\Highlighter\Parser\Token\MetaToken;
use Kadet\Highlighter\Parser\Token\Token;
use Kadet\Highlighter\Parser\TokenFactory;
use Kadet\Highlighter\Parser\TokenFactoryInterface;

class Php extends GreedyLanguage
{
    public function setupRules()
    {
        $allowedInAttributes = ['*none', '*meta.annotation', '!string', '!comment', '!symbol', '!variable'];

        $annotationNameRule = new Rule(new RegexMatcher('/([\w\\\\]+)(\((?:[^()]|(?2))*\))?/m'), [
            'name'     => 'symbol.annotation',
            'context'  => ['*'],
            'language' => $this,
        ]);

        $this->rules->addMany([
            'string' => CommonFeatures::strings(['single' => '\'', 'double' => '"'], [
                'context' => ['!operator.escape', '!comment', '!string', '!expression'],
            ]),

            'string.heredoc' => new Rule(new RegexMatcher(
                '/<<<\s*(\w+)\R(?P<string>.*?)\R\1;/sm',
                ['string' => Token::NAME, 0 => 'keyword.heredoc']
            ), ['context' => ['!comment']]),
            'string.nowdoc'  => new Rule(new RegexMatcher(
                '/<<<\s*\'(\w+)\'\R(?P<string>.*?)\R\1;/sm',
                ['string' => Token::NAME, 0 => 'keyword.nowdoc']
            ), ['context' => ['!comment']]),

            'variable'          => new Rule(new RegexMatcher('/(?:[^\\\]|^)(\$[a-z_]\w*)/i'), [
                'context' => ['*comment.docblock', '!string.nowdoc', '!string.single', '!comment'],
            ]),
            'variable.property' => new Rule(new RegexMatcher('/(?=(?:\w|\)|\])\s*->([a-z_]\w*))/i'), [
                'priority' => -2,
                'context'  => ['*comment.docblock', '!string.nowdoc', '!string.single', '!comment'],
            ]),

            'symbol.function' => new Rule(new RegexMatcher('/function\s+([a-z_]\w+)\s*\(/i')),
            'symbol.class'    => [
                new Rule(new RegexMatcher('/(?:class|new|use|extends)\s+([\w\\\]+)/i')),
                new Rule(new RegexMatcher('/([\w\\\]+)::/i'), ['context' => ['*meta.annotation', '*none']]),
                new Rule(
                    new RegexMatcher('/@(?:var|property(?:-read|-write)?|psalm-[\w-]+)(?:\s+|\s+\$\w+\s+)([^$][\w\\\]+)/i'),
                    ['context' => ['comment.docblock']]
                ),
            ],

            'expression.in-string' => new Rule(new RegexMatcher('/(?=(\{\$((?>[^${}]+|(?1))+)\}))/x'), [
                'context' => ['string'],
                'factory' => new TokenFactory(LanguageToken::class),
                'inject'  => $this,
            ]),

            'symbol.class.interface' => [
                new Rule(new RegexMatcher('/interface\s+([\w\\\]+)/i')),
                new Rule(new DelegateRegexMatcher(
                    '/implements\s+((?:[\w\\\]+)(?:,\s*([\w\\\]+))+)/i',
                    function ($match, TokenFactoryInterface $factory) {
                        foreach (preg_split('/,\s*/', $match[1][0], 0, PREG_SPLIT_OFFSET_CAPTURE) as $interface) {
                            yield $factory->create(Token::NAME, [
                                'pos'    => $match[1][1] + $interface[1],
                                'length' => strlen($interface[0]),
                            ]);
                        }
                    }
                )),
            ],

            'symbol.namespace' => [
                /*new Rule(new RegexMatcher('/(\\\{0,2}(?:\w+\\\{1,2})+)\w+/i'), [
                    'context' => ['*symbol', '*none']
                ]),*/

                new Rule(new RegexMatcher('/namespace\s*(\\\{0,2}(?:\w+\\\{1,2})+\w+);/i'), [
                    'context' => ['*symbol', '*none'],
                ]),
            ],

            'operator.escape' => [
                new Rule(new RegexMatcher('/(\\\(?:x[0-9a-fA-F]{1,2}|u\{[0-9a-fA-F]{1,6}\}|[0-7]{1,3}|[^\'\\\]))/i'), [
                    'context' => ['string.double', '!operator.escape'],
                ]),
                new Rule(new RegexMatcher('/(\\\[\'\\\])/i'), [
                    'context' => ['string', '!operator.escape'],
                ]),
            ],

            'comment' => new Rule(new CommentMatcher(['//', '#'], [
                '$.docblock' => ['/**', '*/'],
                ['/*', '*/'],
            ]), ['priority' => 4]),

            'symbol.annotation' => [
                new Rule(new RegexMatcher('/(?<=[*\s=,({])(@[\w\\\\-]+)/i'), [
                    'context' => ['comment.docblock'],
                ]),
            ],

            'meta.annotation' => [
                new Rule(
                    new DelegateRegexMatcher(
                        '/#(\[(?>[^\[\]]+|(?1))*\])/m',
                        function (
                            $match,
                            TokenFactoryInterface $factory
                        ) use (
                            $annotationNameRule,
                            $allowedInAttributes

                        ) {
                            yield $factory->create(
                                Token::NAME,
                                [
                                    'pos'    => $match[0][1],
                                    'length' => strlen($match[1][0]),
                                ]
                            );

                            // fixme: This should move to some helper? Maybe $offset argument for match?
                            foreach ($annotationNameRule->match($match[0][0]) as $token) {
                                $token->pos += $match[0][1];
                                $token->getEnd()->pos += $match[0][1];
                                yield $token;
                            }
                        }
                    ),
                    [
                        'factory'  => new TokenFactory(MetaToken::class),
                        'priority' => 10,
                    ]
                ),
                new Rule(new RegexMatcher('/(@[\w\\\\](\((?>[^\(\)]+|(?2))*\)))/m'), [
                    'factory'  => new TokenFactory(MetaToken::class),
                    'priority' => 10,
                    'context'  => ['comment.docblock'],
                ]),
            ],
            'call'            => new Rule(new RegexMatcher('/([a-z_]\w*)\s*\(/i'), ['priority' => -1]),

            'constant' => new Rule(new WordMatcher(array_merge([
                '__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__',
                '__LINE__', '__METHOD__', '__NAMESPACE__', '__TRAIT__',
            ], array_keys(get_defined_constants(true)["Core"]))), ['priority' => -2]),
            'constant.static' => new Rule(new RegexMatcher('/(?:[\w\\\]+::|const\s+)(\w+)/i'), ['priority' => -2]),

            'keyword' => new Rule(new WordMatcher([
                '__halt_compiler', 'abstract', 'and',
                'as', 'break', 'case', 'catch',
                'class', 'clone', 'const', 'continue', 'declare',
                'default', 'die', 'do', 'echo', 'else', 'elseif',
                'empty', 'enddeclare', 'endfor', 'endforeach', 'endif',
                'endswitch', 'endwhile', 'enum', 'eval', 'exit', 'extends',
                'final', 'finally', 'for', 'foreach', 'function',
                'global', 'goto', 'if', 'implements', 'include', 'include_once',
                'instanceof', 'insteadof', 'interface', 'isset', 'list',
                'namespace', 'new', 'or', 'print', 'private', 'protected',
                'public', 'require', 'require_once', 'return', 'static',
                'switch', 'throw', 'trait', 'try', 'unset', 'parent', 'self',
                'use', 'var', 'while', 'xor', 'yield'
            ]), ['context' => ['!string', '!variable', '!comment']]),

            'symbol.type' => new Rule(new WordMatcher([
                'integer', 'float', 'string', 'boolean', 'false', 'never',
                'array', 'object', 'callable', 'void', 'mixed', 'true', 'null'
            ]), ['context' => ['!string', '!variable', '!comment', '!keyword']]),

            'keyword.cast' => new Rule(
                new RegexMatcher('/(\((?:int|integer|bool|boolean|float|double|real|string|array|object|unset)\))/')
            ),

            'label.argument' => [
                new Rule(new RegexMatcher('/(\w+):/'), ['context' => $allowedInAttributes]),
            ],

            'delimiter' => new Rule(new RegexMatcher('/(<\?php|<\?=|\?>)/')),
            'number'    => new Rule(new RegexMatcher('/(-?(?:0[0-7]+|0[xX][0-9a-fA-F]+|0b[01]+|\d+))/'), [
                'context' => $allowedInAttributes,
            ]),

            'operator.punctuation' => new Rule(new WordMatcher([',', ';'], ['separated' => false]), [
                'priority' => 0,
                'context'  => $allowedInAttributes,
            ]),
        ]);
    }

    /** {@inheritdoc} */
    public function getEnds($embedded = false)
    {
        return $embedded ? [
            new OpenRule(new RegexMatcher('/(<\?php|<\?=)/si'), [
                'factory'  => new TokenFactory(LanguageToken::class),
                'priority' => 1000,
                'context'  => ['*'],
                'inject'   => $this,
                'language' => null,
            ]),
            new CloseRule(new RegexMatcher('/(\?>|$)/'), [
                'context'  => ['!string', '!comment'],
                'priority' => 1000,
                'factory'  => new TokenFactory(LanguageToken::class),
                'language' => $this,
            ]),
        ] : parent::getEnds(false);
    }

    public function getIdentifier()
    {
        return 'php';
    }

    public static function getMetadata()
    {
        return [
            'name'       => ['php'],
            'mime'       => ['text/x-php', 'application/x-php'],
            'extension'  => ['*.php', '*.phtml', '*.inc', '*.php?'],
            'injectable' => true,
        ];
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/**
6		* Highlighter
7		*
8		* Copyright (C) 2016, Some right reserved.
9		*
10		* @author Kacper "Kadet" Donat <[email protected]>
11		*
12		* Contact with author:
13		* Xmpp: [email protected]
14		* E-mail: [email protected]
15		*
16		* From Kadet with love.
17		*/
18
19		namespace Kadet\Highlighter\Language;
20
21		use Kadet\Highlighter\Matcher\CommentMatcher;
22		use Kadet\Highlighter\Matcher\DelegateRegexMatcher;
23		use Kadet\Highlighter\Matcher\RegexMatcher;
24		use Kadet\Highlighter\Matcher\WordMatcher;
25		use Kadet\Highlighter\Parser\CloseRule;
26		use Kadet\Highlighter\Parser\OpenRule;
27		use Kadet\Highlighter\Parser\Rule;
28		use Kadet\Highlighter\Parser\Token\LanguageToken;
29		use Kadet\Highlighter\Parser\Token\MetaToken;
30		use Kadet\Highlighter\Parser\Token\Token;
31		use Kadet\Highlighter\Parser\TokenFactory;
32		use Kadet\Highlighter\Parser\TokenFactoryInterface;
33
34		class Php extends GreedyLanguage
35		{
36	2	public function setupRules()
37		{
38	1	$allowedInAttributes = ['none', 'meta.annotation', '!string', '!comment', '!symbol', '!variable'];
39
40	1	$annotationNameRule = new Rule(new RegexMatcher('/([\w\\\\]+)(\((?:[^()]\|(?2))*\))?/m'), [
41	1	'name' => 'symbol.annotation',
42		'context' => ['*'],
43	1	'language' => $this,
44		]);
45
46	1	$this->rules->addMany([
47	1	'string' => CommonFeatures::strings(['single' => '\'', 'double' => '"'], [
48	1	'context' => ['!operator.escape', '!comment', '!string', '!expression'],
49		]),
50
51	1	'string.heredoc' => new Rule(new RegexMatcher(
52	1	'/<<<\s(\w+)\R(?P<string>.?)\R\1;/sm',
53	1	['string' => Token::NAME, 0 => 'keyword.heredoc']
54	1	), ['context' => ['!comment']]),
55	1	'string.nowdoc' => new Rule(new RegexMatcher(
56	1	'/<<<\s\'(\w+)\'\R(?P<string>.?)\R\1;/sm',
57	1	['string' => Token::NAME, 0 => 'keyword.nowdoc']
58	1	), ['context' => ['!comment']]),
59
60	1	'variable' => new Rule(new RegexMatcher('/(?:[^\\\]\|^)(\$[a-z_]\w*)/i'), [
61	1	'context' => ['*comment.docblock', '!string.nowdoc', '!string.single', '!comment'],
62		]),
63	1	'variable.property' => new Rule(new RegexMatcher('/(?=(?:\w\|\)\|\])\s->([a-z_]\w))/i'), [
64	1	'priority' => -2,
65		'context' => ['*comment.docblock', '!string.nowdoc', '!string.single', '!comment'],
66		]),
67
68	1	'symbol.function' => new Rule(new RegexMatcher('/function\s+([a-z_]\w+)\s*\(/i')),
69		'symbol.class' => [
70	1	new Rule(new RegexMatcher('/(?:class\|new\|use\|extends)\s+([\w\\\]+)/i')),
71	1	new Rule(new RegexMatcher('/([\w\\\]+)::/i'), ['context' => ['meta.annotation', 'none']]),
72	1	new Rule(
73	1	new RegexMatcher('/@(?:var\|property(?:-read\|-write)?\|psalm-[\w-]+)(?:\s+\|\s+\$\w+\s+)([^$][\w\\\]+)/i'),
74	1	['context' => ['comment.docblock']]
75		),
76		],
77
78	1	'expression.in-string' => new Rule(new RegexMatcher('/(?=(\{\$((?>[^${}]+\|(?1))+)\}))/x'), [
79	1	'context' => ['string'],
80	1	'factory' => new TokenFactory(LanguageToken::class),
81	1	'inject' => $this,
82		]),
83
84		'symbol.class.interface' => [
85	1	new Rule(new RegexMatcher('/interface\s+([\w\\\]+)/i')),
86	1	new Rule(new DelegateRegexMatcher(
87	1	'/implements\s+((?:[\w\\\]+)(?:,\s*([\w\\\]+))+)/i',
88	1	function ($match, TokenFactoryInterface $factory) {
89		foreach (preg_split('/,\s*/', $match[1][0], 0, PREG_SPLIT_OFFSET_CAPTURE) as $interface) {
90		yield $factory->create(Token::NAME, [
91		'pos' => $match[1][1] + $interface[1],
92		'length' => strlen($interface[0]),
93		]);
94		}
95	1	}
96		)),
97		],
98
99		'symbol.namespace' => [
100		/*new Rule(new RegexMatcher('/(\\\{0,2}(?:\w+\\\{1,2})+)\w+/i'), [
101		'context' => ['symbol', 'none']
102		]),*/
103
104	1	new Rule(new RegexMatcher('/namespace\s*(\\\{0,2}(?:\w+\\\{1,2})+\w+);/i'), [
105	1	'context' => ['symbol', 'none'],
106		]),
107		],
108
109		'operator.escape' => [
110	1	new Rule(new RegexMatcher('/(\\\(?:x[0-9a-fA-F]{1,2}\|u\{[0-9a-fA-F]{1,6}\}\|[0-7]{1,3}\|[^\'\\\]))/i'), [
111	1	'context' => ['string.double', '!operator.escape'],
112		]),
113	1	new Rule(new RegexMatcher('/(\\\[\'\\\])/i'), [
114	1	'context' => ['string', '!operator.escape'],
115		]),
116		],
117
118	1	'comment' => new Rule(new CommentMatcher(['//', '#'], [
119	1	'$.docblock' => ['/*', '/'],
120		['/', '/'],
121	1	]), ['priority' => 4]),
122
123		'symbol.annotation' => [
124	1	new Rule(new RegexMatcher('/(?<=[*\s=,({])(@[\w\\\\-]+)/i'), [
125	1	'context' => ['comment.docblock'],
126		]),
127		],
128
129		'meta.annotation' => [
130	1	new Rule(
131	1	new DelegateRegexMatcher(
132	1	'/#(\[(?>[^\[\]]+\|(?1))*\])/m',
133	2	function (
134		$match,
135		TokenFactoryInterface $factory
136		) use (
137	1	$annotationNameRule,
138	1	$allowedInAttributes
		0 ignored issues – show Unused Code introduced 2024-01-13 21:13 UTC by Report Bug Copy Issue Report The import `$allowedInAttributes` is not used and could be removed. This check looks for imports that have been defined, but are not used in the scope. Loading history...
139		) {
140	1	yield $factory->create(
141	1	Token::NAME,
142		[
143	1	'pos' => $match[0][1],
144	1	'length' => strlen($match[1][0]),
145		]
146		);
147
148		// fixme: This should move to some helper? Maybe $offset argument for match?
149	1	foreach ($annotationNameRule->match($match[0][0]) as $token) {
150	1	$token->pos += $match[0][1];
151	1	$token->getEnd()->pos += $match[0][1];
152	1	yield $token;
153		}
154	2	}
155		),
156		[
157	1	'factory' => new TokenFactory(MetaToken::class),
158	1	'priority' => 10,
159		]
160		),
161	1	new Rule(new RegexMatcher('/(@[\w\\\\](\((?>[^\(\)]+\|(?2))*\)))/m'), [
162	1	'factory' => new TokenFactory(MetaToken::class),
163	1	'priority' => 10,
164		'context' => ['comment.docblock'],
165		]),
166		],
167	1	'call' => new Rule(new RegexMatcher('/([a-z_]\w)\s\(/i'), ['priority' => -1]),
168
169	1	'constant' => new Rule(new WordMatcher(array_merge([
170	1	'__CLASS__', '__DIR__', '__FILE__', '__FUNCTION__',
171		'__LINE__', '__METHOD__', '__NAMESPACE__', '__TRAIT__',
172	1	], array_keys(get_defined_constants(true)["Core"]))), ['priority' => -2]),
173	1	'constant.static' => new Rule(new RegexMatcher('/(?:[\w\\\]+::\|const\s+)(\w+)/i'), ['priority' => -2]),
174
175	1	'keyword' => new Rule(new WordMatcher([
176	1	'__halt_compiler', 'abstract', 'and',
177		'as', 'break', 'case', 'catch',
178		'class', 'clone', 'const', 'continue', 'declare',
179		'default', 'die', 'do', 'echo', 'else', 'elseif',
180		'empty', 'enddeclare', 'endfor', 'endforeach', 'endif',
181		'endswitch', 'endwhile', 'enum', 'eval', 'exit', 'extends',
182		'final', 'finally', 'for', 'foreach', 'function',
183		'global', 'goto', 'if', 'implements', 'include', 'include_once',
184		'instanceof', 'insteadof', 'interface', 'isset', 'list',
185		'namespace', 'new', 'or', 'print', 'private', 'protected',
186		'public', 'require', 'require_once', 'return', 'static',
187		'switch', 'throw', 'trait', 'try', 'unset', 'parent', 'self',
188		'use', 'var', 'while', 'xor', 'yield'
189	1	]), ['context' => ['!string', '!variable', '!comment']]),
190
191	1	'symbol.type' => new Rule(new WordMatcher([
192	1	'integer', 'float', 'string', 'boolean', 'false', 'never',
193		'array', 'object', 'callable', 'void', 'mixed', 'true', 'null'
194	1	]), ['context' => ['!string', '!variable', '!comment', '!keyword']]),
195
196	1	'keyword.cast' => new Rule(
197	1	new RegexMatcher('/(\((?:int\|integer\|bool\|boolean\|float\|double\|real\|string\|array\|object\|unset)\))/')
198		),
199
200		'label.argument' => [
201	1	new Rule(new RegexMatcher('/(\w+):/'), ['context' => $allowedInAttributes]),
202		],
203
204	1	'delimiter' => new Rule(new RegexMatcher('/(<\?php\|<\?=\|\?>)/')),
205	1	'number' => new Rule(new RegexMatcher('/(-?(?:0[0-7]+\|0[xX][0-9a-fA-F]+\|0b[01]+\|\d+))/'), [
206	1	'context' => $allowedInAttributes,
207		]),
208
209	1	'operator.punctuation' => new Rule(new WordMatcher([',', ';'], ['separated' => false]), [
210	1	'priority' => 0,
211	1	'context' => $allowedInAttributes,
212		]),
213		]);
214	1	}
215
216		/** {@inheritdoc} */
217	6	public function getEnds($embedded = false)
218		{
219	6	return $embedded ? [
220		new OpenRule(new RegexMatcher('/(<\?php\|<\?=)/si'), [
221		'factory' => new TokenFactory(LanguageToken::class),
222		'priority' => 1000,
223		'context' => ['*'],
224		'inject' => $this,
225		'language' => null,
226		]),
227		new CloseRule(new RegexMatcher('/(\?>\|$)/'), [
228		'context' => ['!string', '!comment'],
229		'priority' => 1000,
230		'factory' => new TokenFactory(LanguageToken::class),
231		'language' => $this,
232		]),
233	6	] : parent::getEnds(false);
234		}
235
236	7	public function getIdentifier()
237		{
238	7	return 'php';
239		}
240
241		public static function getMetadata()
242		{
243		return [
244		'name' => ['php'],
245		'mime' => ['text/x-php', 'application/x-php'],
246		'extension' => ['.php', '.phtml', '.inc', '.php?'],
247		'injectable' => true,
248		];
249		}
250		}
251

kadet1090 / KeyLighter

Push — master ( 83eaad...7faa90 )

Php::getMetadata() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like