├── .github
    ├── FUNDING.yml
    ├── highlight.png
    ├── terminal.png
    ├── highlight-2.png
    ├── highlight-3.png
    └── highlight-4.png
├── .gitignore
├── tests
    ├── targets
    │   ├── test.md
    │   ├── python.md
    │   ├── ellison.md
    │   └── gdscript.md
    ├── stylesheets
    │   └── ellison.css
    ├── Themes
    │   ├── InlineThemeTest.php
    │   ├── LightTerminalThemeTest.php
    │   └── TerminalThemeTest.php
    ├── Languages
    │   ├── Php
    │   │   ├── Patterns
    │   │   │   ├── UsePatternTest.php
    │   │   │   ├── ExtendsPatternTest.php
    │   │   │   ├── FunctionCallPatternTest.php
    │   │   │   ├── NamespacePatternTest.php
    │   │   │   ├── FunctionNamePatternTest.php
    │   │   │   ├── SinglelineDocCommentPatternTest.php
    │   │   │   ├── ClassNamePatternTest.php
    │   │   │   ├── ConstantPropertyPatternTest.php
    │   │   │   ├── NestedFunctionCallPatternTest.php
    │   │   │   ├── MultilineSingleDocCommentPatternTest.php
    │   │   │   ├── KeywordPatternTest.php
    │   │   │   ├── PropertyAccessPatternTest.php
    │   │   │   └── NamedArgumentPatternTest.php
    │   │   └── Injections
    │   │   │   └── PhpShortEchoInjectionTest.php
    │   ├── Base
    │   │   └── Injections
    │   │   │   ├── AdditionInjectionTest.php
    │   │   │   └── DeletionInjectionTest.php
    │   ├── Blade
    │   │   ├── Injections
    │   │   │   ├── BladeEchoInjectionTest.php
    │   │   │   ├── BladeRawEchoInjectionTest.php
    │   │   │   ├── BladeKeywordInjectionTest.php
    │   │   │   └── BladePhpInjectionTest.php
    │   │   └── BladeLanguageTest.php
    │   ├── Css
    │   │   └── Injections
    │   │   │   └── CssAttributeInjectionTest.php
    │   ├── Twig
    │   │   ├── Injections
    │   │   │   └── TwigEchoInjectionTest.php
    │   │   └── Patterns
    │   │   │   ├── TwigKeywordPatternTest.php
    │   │   │   └── TwigTokenPatternTest.php
    │   ├── Text
    │   │   └── TextLanguageTest.php
    │   ├── Diff
    │   │   └── DiffLanguageTest.php
    │   ├── Xml
    │   │   └── XmlLanguageTest.php
    │   └── Json
    │   │   └── JsonLanguageTest.php
    ├── TokenTest.php
    ├── TestsInjections.php
    └── CommonMark
    │   └── HighlightExtensionTest.php
├── phpstan.neon.dist
├── test-server.php
├── src
    ├── TerminalTheme.php
    ├── Injection.php
    ├── Tokens
    │   ├── TokenType.php
    │   ├── IgnoreTokenType.php
    │   ├── DynamicTokenType.php
    │   └── TokenTypeEnum.php
    ├── After.php
    ├── Before.php
    ├── WebTheme.php
    ├── Pattern.php
    ├── Themes
    │   ├── EscapesWebTheme.php
    │   ├── EscapesTerminalTheme.php
    │   └── Css
    │   │   ├── ellison.css
    │   │   ├── highlight-dark-lite.css
    │   │   └── highlight-light-lite.css
    ├── Theme.php
    ├── PatternTest.php
    ├── Languages
    │   ├── Text
    │   │   └── TextLanguage.php
    │   ├── Base
    │   │   ├── Injections
    │   │   │   ├── BlurInjection.php
    │   │   │   ├── StrongInjection.php
    │   │   │   └── EmphasizeInjection.php
    │   │   └── Patterns
    │   │   │   ├── InjectionTokenPattern.php
    │   │   │   ├── AdditionEndTokenPattern.php
    │   │   │   ├── AdditionStartTokenPattern.php
    │   │   │   ├── DeletionEndTokenPattern.php
    │   │   │   └── DeletionStartTokenPattern.php
    │   ├── Php
    │   │   ├── Patterns
    │   │   │   ├── UsePattern.php
    │   │   │   ├── NamedArgumentPattern.php
    │   │   │   ├── NamespacePattern.php
    │   │   │   ├── PropertyAccessPattern.php
    │   │   │   ├── ConstantPropertyPattern.php
    │   │   │   ├── FunctionCallPattern.php
    │   │   │   ├── FunctionNamePattern.php
    │   │   │   ├── SinglelineCommentPattern.php
    │   │   │   ├── NestedFunctionCallPattern.php
    │   │   │   ├── MultilineSingleDocCommentPattern.php
    │   │   │   ├── PhpCloseTagPattern.php
    │   │   │   ├── VariablePattern.php
    │   │   │   ├── ExtendsPattern.php
    │   │   │   ├── ShortFunctionReferencePattern.php
    │   │   │   ├── ClassResolutionPattern.php
    │   │   │   ├── OperatorPattern.php
    │   │   │   ├── GenericPattern.php
    │   │   │   ├── PhpDocCommentTemplateTypePattern.php
    │   │   │   ├── DoubleQuoteValuePattern.php
    │   │   │   ├── UseFunctionNamePattern.php
    │   │   │   ├── UseFunctionPattern.php
    │   │   │   ├── PhpDocCommentGenericTypePattern.php
    │   │   │   ├── PhpOpenTagPattern.php
    │   │   │   ├── UseAsPattern.php
    │   │   │   ├── StaticPropertyPattern.php
    │   │   │   ├── ImplementsPattern.php
    │   │   │   ├── EnumBackedTypePattern.php
    │   │   │   ├── InstanceOfPattern.php
    │   │   │   ├── PhpDocCommentReturnTypePattern.php
    │   │   │   ├── PhpDocCommentParamTypePattern.php
    │   │   │   ├── StaticClassCallPattern.php
    │   │   │   ├── CatchTypePattern.php
    │   │   │   ├── GroupedTypePattern.php
    │   │   │   ├── PhpDocCommentReturnTypeSingleLinePattern.php
    │   │   │   ├── NewObjectPattern.php
    │   │   │   ├── UntypedClassPropertyPattern.php
    │   │   │   ├── PropertyHookSetParameterTypePattern.php
    │   │   │   ├── EnumCasePattern.php
    │   │   │   ├── ConstantTypesPattern.php
    │   │   │   ├── ClassNamePattern.php
    │   │   │   ├── PropertyHookGetPattern.php
    │   │   │   ├── PhpDocCommentVariablePattern.php
    │   │   │   ├── ConstantNamePattern.php
    │   │   │   ├── PropertyHookSetPattern.php
    │   │   │   ├── SingleQuoteValuePattern.php
    │   │   │   ├── PhpDocCommentVarTypePattern.php
    │   │   │   ├── AttributeTypePattern.php
    │   │   │   ├── KeywordPattern.php
    │   │   │   ├── TypeForVariablePattern.php
    │   │   │   ├── ReturnTypePattern.php
    │   │   │   ├── ClassPropertyPattern.php
    │   │   │   └── PhpAsymmetricPropertyPattern.php
    │   │   └── Injections
    │   │   │   ├── PhpDocCommentInjection.php
    │   │   │   ├── PhpFunctionParametersInjection.php
    │   │   │   ├── PhpAttributePlainInjection.php
    │   │   │   └── PhpAttributeInstanceInjection.php
    │   ├── Ellison
    │   │   └── EllisonLanguage.php
    │   ├── Python
    │   │   └── Patterns
    │   │   │   ├── PyCommentPattern.php
    │   │   │   ├── PyArgumentPattern.php
    │   │   │   ├── PyLogicalValuePattern.php
    │   │   │   ├── PyTripleDoubleQuoteStringPattern.php
    │   │   │   ├── PyTripleSingleQuoteStringPattern.php
    │   │   │   ├── PyOperatorPattern.php
    │   │   │   ├── PyFunctionPattern.php
    │   │   │   ├── PyNumberPattern.php
    │   │   │   ├── PyClassNamePattern.php
    │   │   │   ├── PyDecoratorPattern.php
    │   │   │   └── PyKeywordPattern.php
    │   ├── Blade
    │   │   ├── Injections
    │   │   │   ├── BladeEchoInjection.php
    │   │   │   ├── BladePhpInjection.php
    │   │   │   ├── BladeRawEchoInjection.php
    │   │   │   └── BladeKeywordInjection.php
    │   │   └── Patterns
    │   │   │   ├── BladeKeywordPattern.php
    │   │   │   ├── BladeCommentPattern.php
    │   │   │   ├── BladeComponentCloseTagPattern.php
    │   │   │   └── BladeComponentOpenTagPattern.php
    │   ├── Html
    │   │   ├── Injections
    │   │   │   ├── PhpInHtmlInjection.php
    │   │   │   ├── CssInHtmlInjection.php
    │   │   │   ├── PhpShortEchoInHtmlInjection.php
    │   │   │   ├── CssAttributeInHtmlInjection.php
    │   │   │   └── JavaScriptInHtmlInjection.php
    │   │   └── HtmlLanguage.php
    │   ├── Twig
    │   │   ├── Patterns
    │   │   │   ├── TwigKeywordPattern.php
    │   │   │   ├── TwigMethodPattern.php
    │   │   │   ├── TwigPropertyPattern.php
    │   │   │   ├── TwigFilterPattern.php
    │   │   │   ├── TwigNamedArgumentPattern.php
    │   │   │   ├── TwigArrayKeyPattern.php
    │   │   │   ├── TwigDoubleQuoteValuePattern.php
    │   │   │   ├── TwigSingleQuoteValuePattern.php
    │   │   │   ├── TwigTokenPattern.php
    │   │   │   └── TwigCommentPattern.php
    │   │   ├── Injections
    │   │   │   ├── TwigEchoInjection.php
    │   │   │   └── TwigTagInjection.php
    │   │   └── TwigLanguage.php
    │   ├── Css
    │   │   └── Patterns
    │   │   │   ├── CssImportPattern.php
    │   │   │   ├── CssVariablePattern.php
    │   │   │   ├── CssCommentPattern.php
    │   │   │   ├── CssAttributePattern.php
    │   │   │   ├── CssFunctionPattern.php
    │   │   │   ├── CssMediaQueryPattern.php
    │   │   │   └── CssSelectorPattern.php
    │   ├── Gdscript
    │   │   └── Patterns
    │   │   │   ├── ExtendsPattern.php
    │   │   │   ├── KeywordPattern.php
    │   │   │   ├── AsTypePattern.php
    │   │   │   ├── ClassNamePattern.php
    │   │   │   ├── FunctionNamePattern.php
    │   │   │   ├── SinglelineCommentPattern.php
    │   │   │   ├── PropertyAccessPattern.php
    │   │   │   ├── DoubleQuoteValuePattern.php
    │   │   │   ├── SingleQuoteValuePattern.php
    │   │   │   ├── FunctionCallPattern.php
    │   │   │   ├── OperatorPattern.php
    │   │   │   ├── ReturnTypePattern.php
    │   │   │   └── VarTypePattern.php
    │   ├── Yaml
    │   │   └── Patterns
    │   │   │   ├── YamlCommentPattern.php
    │   │   │   ├── YamlDoubleQuoteValuePattern.php
    │   │   │   ├── YamlSingleQuoteValuePattern.php
    │   │   │   ├── YamlDashPattern.php
    │   │   │   ├── YamlArrayBracketsPattern.php
    │   │   │   ├── YamlPipePattern.php
    │   │   │   ├── YamlVariablePattern.php
    │   │   │   ├── YamlDoubleAccoladesValuePattern.php
    │   │   │   ├── YamlObjectBracketsPattern.php
    │   │   │   ├── YamlPropertyPattern.php
    │   │   │   └── YamlColonPattern.php
    │   ├── DocComment
    │   │   ├── Patterns
    │   │   │   └── DocCommentTagPattern.php
    │   │   └── DocCommentLanguage.php
    │   ├── JavaScript
    │   │   ├── Patterns
    │   │   │   ├── JsMethodPattern.php
    │   │   │   ├── JsPropertyPattern.php
    │   │   │   ├── JsClassNamePattern.php
    │   │   │   ├── JsStaticPropertyPattern.php
    │   │   │   ├── JsSinglelineCommentPattern.php
    │   │   │   ├── JsObjectPropertyPattern.php
    │   │   │   ├── JsDocTypePattern.php
    │   │   │   ├── JsDoubleQuoteValuePattern.php
    │   │   │   ├── JsSingleQuoteValuePattern.php
    │   │   │   ├── JsStaticClassPattern.php
    │   │   │   ├── JsMultilineCommentPattern.php
    │   │   │   ├── JsNewObjectPattern.php
    │   │   │   ├── JsDocParamNamePattern.php
    │   │   │   └── JsKeywordPattern.php
    │   │   ├── Injections
    │   │   │   └── JsDocInjection.php
    │   │   └── JsDocLanguage.php
    │   ├── Json
    │   │   ├── Patterns
    │   │   │   ├── JsonAccoladesPattern.php
    │   │   │   ├── JsonDoubleQuoteValuePattern.php
    │   │   │   ├── JsonPropertyPattern.php
    │   │   │   └── JsonArrayBracketsPattern.php
    │   │   └── JsonLanguage.php
    │   ├── Sql
    │   │   └── Patterns
    │   │   │   ├── SqlDoubleQuoteValuePattern.php
    │   │   │   ├── SqlSingleQuoteValuePattern.php
    │   │   │   ├── SqlTablePropertyPattern.php
    │   │   │   ├── SqlTableAccessPattern.php
    │   │   │   ├── SqlPropertyPattern.php
    │   │   │   ├── SqlSinglelineCommentPattern.php
    │   │   │   ├── SqlFunctionPattern.php
    │   │   │   ├── SqlFromTablePattern.php
    │   │   │   ├── SqlAsTablePattern.php
    │   │   │   ├── SqlJoinTablePattern.php
    │   │   │   └── SqlMultilineCommentPattern.php
    │   ├── Diff
    │   │   ├── DiffLanguage.php
    │   │   └── Injections
    │   │   │   ├── DiffAdditionInjection.php
    │   │   │   └── DiffDeletionInjection.php
    │   ├── Dockerfile
    │   │   └── Patterns
    │   │   │   ├── KeywordPattern.php
    │   │   │   ├── ImageAliasKeywordPattern.php
    │   │   │   ├── ImageAliasNamePattern.php
    │   │   │   ├── ImageNamePattern.php
    │   │   │   └── ImageTagPattern.php
    │   └── Xml
    │   │   ├── Patterns
    │   │       ├── XmlCloseTagPattern.php
    │   │       ├── XmlOpenTagPattern.php
    │   │       ├── XmlAttributePattern.php
    │   │       └── XmlCommentPattern.php
    │   │   └── XmlLanguage.php
    ├── Language.php
    ├── IsPattern.php
    ├── ParsedInjection.php
    ├── CommonMark
    │   ├── HighlightExtension.php
    │   └── InlineCodeBlockRenderer.php
    └── IsInjection.php
├── README.md
├── test-terminal.php
├── phpunit.xml
└── LICENCE.md


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: brendt
4 | 


--------------------------------------------------------------------------------
/.github/highlight.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yilanboy/highlight/main/.github/highlight.png


--------------------------------------------------------------------------------
/.github/terminal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yilanboy/highlight/main/.github/terminal.png


--------------------------------------------------------------------------------
/.github/highlight-2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yilanboy/highlight/main/.github/highlight-2.png


--------------------------------------------------------------------------------
/.github/highlight-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yilanboy/highlight/main/.github/highlight-3.png


--------------------------------------------------------------------------------
/.github/highlight-4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yilanboy/highlight/main/.github/highlight-4.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | .phpunit.result.cache
3 | composer.lock
4 | /.php-cs-fixer.cache
5 | .env
6 | .idea
7 | build/


--------------------------------------------------------------------------------
/tests/targets/test.md:
--------------------------------------------------------------------------------
1 | ```php
2 | public function __construct(
3 |     private(set) Author $author,
4 | ) {}
5 | ```


--------------------------------------------------------------------------------
/phpstan.neon.dist:
--------------------------------------------------------------------------------
1 | parameters:
2 | 	level: 1
3 | 	reportUnmatchedIgnoredErrors: false
4 | 	paths:
5 | 		- src
6 | 		- tests


--------------------------------------------------------------------------------
/test-server.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require_once __DIR__ . '/vendor/autoload.php';
4 | 
5 | passthru("php -S localhost:8000 -t tests/");


--------------------------------------------------------------------------------
/src/TerminalTheme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | interface TerminalTheme extends Theme
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Injection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | interface Injection
 8 | {
 9 |     public function parse(string $content, Highlighter $highlighter): ParsedInjection;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Tokens/TokenType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tokens;
 6 | 
 7 | interface TokenType
 8 | {
 9 |     public function getValue(): string;
10 | 
11 |     public function canContain(TokenType $other): bool;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/After.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final readonly class After
11 | {
12 |     public function __construct()
13 |     {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Before.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_CLASS)]
10 | final readonly class Before
11 | {
12 |     public function __construct()
13 |     {
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/WebTheme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | interface WebTheme extends Theme
 8 | {
 9 |     public function preBefore(Highlighter $highlighter): string;
10 | 
11 |     public function preAfter(Highlighter $highlighter): string;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Pattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | use Tempest\Highlight\Tokens\TokenType;
 8 | 
 9 | interface Pattern
10 | {
11 |     public function match(string $content): array;
12 | 
13 |     public function getTokenType(): TokenType;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Themes/EscapesWebTheme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Themes;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | 
 9 | trait EscapesWebTheme
10 | {
11 |     public function escape(string $content): string
12 |     {
13 |         return Escape::html($content);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Themes/EscapesTerminalTheme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Themes;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | 
 9 | trait EscapesTerminalTheme
10 | {
11 |     public function escape(string $content): string
12 |     {
13 |         return Escape::terminal($content);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Theme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | use Tempest\Highlight\Tokens\TokenType;
 8 | 
 9 | interface Theme
10 | {
11 |     public function before(TokenType $tokenType): string;
12 | 
13 |     public function after(TokenType $tokenType): string;
14 | 
15 |     public function escape(string $content): string;
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/targets/python.md:
--------------------------------------------------------------------------------
 1 | ```py
 2 | # Python program to check if the input number is odd or even.
 3 | # A number is even if division by 2 gives a remainder of 0.
 4 | # If the remainder is 1, it is an odd number.
 5 | 
 6 | num = int(input("Enter a number: "))
 7 | if (num % 2) == 0:
 8 |    print("{0} is Even".format(num))
 9 | else:
10 |    print("{0} is Odd".format(num))
11 | ```


--------------------------------------------------------------------------------
/src/PatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::IS_REPEATABLE | Attribute::TARGET_CLASS)]
10 | final readonly class PatternTest
11 | {
12 |     public function __construct(
13 |         public string $input,
14 |         public string|array|null $output,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Tokens/IgnoreTokenType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tokens;
 6 | 
 7 | final readonly class IgnoreTokenType implements TokenType
 8 | {
 9 |     public function getValue(): string
10 |     {
11 |         return 'ignore';
12 |     }
13 | 
14 |     public function canContain(TokenType $other): bool
15 |     {
16 |         return false;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Themes/Css/ellison.css:
--------------------------------------------------------------------------------
 1 | .hl-moderate-sentence {
 2 |     background-color: #fef9c3;
 3 | }
 4 | 
 5 | .hl-complex-sentence {
 6 |     background-color: #fee2e2;
 7 | }
 8 | 
 9 | .hl-adverb-phrase {
10 |     background-color: #e0f2fe;
11 | }
12 | 
13 | .hl-passive-phrase {
14 |     background-color: #dcfce7;
15 | }
16 | 
17 | .hl-complex-phrase {
18 |     background-color: #f3e8ff;
19 | }
20 | 
21 | .hl-qualified-phrase {
22 |     background-color: #f1f5f9;
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/stylesheets/ellison.css:
--------------------------------------------------------------------------------
 1 | .hl-moderate-sentence {
 2 |     background-color: #fef9c3;
 3 | }
 4 | 
 5 | .hl-complex-sentence {
 6 |     background-color: #fee2e2;
 7 | }
 8 | 
 9 | .hl-adverb-phrase {
10 |     background-color: #e0f2fe;
11 | }
12 | 
13 | .hl-passive-phrase {
14 |     background-color: #dcfce7;
15 | }
16 | 
17 | .hl-complex-phrase {
18 |     background-color: #f3e8ff;
19 | }
20 | 
21 | .hl-qualified-phrase {
22 |     background-color: #f1f5f9;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Text/TextLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Text;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | 
 9 | class TextLanguage extends BaseLanguage
10 | {
11 |     public function getName(): string
12 |     {
13 |         return 'txt';
14 |     }
15 | 
16 |     public function getAliases(): array
17 |     {
18 |         return [
19 |             'text',
20 |         ];
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Themes/InlineThemeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Themes;
 6 | 
 7 | use Exception;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Themes\InlineTheme;
10 | 
11 | class InlineThemeTest extends TestCase
12 | {
13 |     public function test_invalid_css_path(): void
14 |     {
15 |         $this->expectException(Exception::class);
16 | 
17 |         new InlineTheme('invalid/path.css');
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Language.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | interface Language
 8 | {
 9 |     public function getName(): string;
10 | 
11 |     public function getAliases(): array;
12 | 
13 |     /**
14 |      * @return \Tempest\Highlight\Injection[]
15 |      */
16 |     public function getInjections(): array;
17 | 
18 |     /**
19 |      * @return \Tempest\Highlight\Pattern[]
20 |      */
21 |     public function getPatterns(): array;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Tokens/DynamicTokenType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tokens;
 6 | 
 7 | final readonly class DynamicTokenType implements TokenType
 8 | {
 9 |     public function __construct(private string $value)
10 |     {
11 |     }
12 | 
13 |     public function getValue(): string
14 |     {
15 |         return $this->value;
16 |     }
17 | 
18 |     public function canContain(TokenType $other): bool
19 |     {
20 |         return $this->getValue() !== $other->getValue();
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/IsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | trait IsPattern
 8 | {
 9 |     abstract public function getPattern(): string;
10 | 
11 |     public function match(string $content): array
12 |     {
13 |         $pattern = $this->getPattern();
14 | 
15 |         if (! str_starts_with($pattern, '/')) {
16 |             $pattern = "/$pattern/";
17 |         }
18 | 
19 |         preg_match_all($pattern, $content, $matches, PREG_OFFSET_CAPTURE);
20 | 
21 |         return $matches;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Injections/BlurInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Injections;
 6 | 
 7 | use Tempest\Highlight\Injection;
 8 | use Tempest\Highlight\Languages\Base\IsHighlightInjection;
 9 | 
10 | final readonly class BlurInjection implements Injection
11 | {
12 |     use IsHighlightInjection;
13 | 
14 |     private function getToken(): string
15 |     {
16 |         return '~';
17 |     }
18 | 
19 |     private function getClassname(): string
20 |     {
21 |         return 'hl-blur';
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Injections/StrongInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Injections;
 6 | 
 7 | use Tempest\Highlight\Injection;
 8 | use Tempest\Highlight\Languages\Base\IsHighlightInjection;
 9 | 
10 | final readonly class StrongInjection implements Injection
11 | {
12 |     use IsHighlightInjection;
13 | 
14 |     private function getToken(): string
15 |     {
16 |         return '*';
17 |     }
18 | 
19 |     private function getClassname(): string
20 |     {
21 |         return 'hl-strong';
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Injections/EmphasizeInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Injections;
 6 | 
 7 | use Tempest\Highlight\Injection;
 8 | use Tempest\Highlight\Languages\Base\IsHighlightInjection;
 9 | 
10 | final readonly class EmphasizeInjection implements Injection
11 | {
12 |     use IsHighlightInjection;
13 | 
14 |     private function getToken(): string
15 |     {
16 |         return '_';
17 |     }
18 | 
19 |     private function getClassname(): string
20 |     {
21 |         return 'hl-em';
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/UsePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class UsePattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return 'use (?<match>[\w\\\\]+)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::TYPE;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Ellison/EllisonLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Ellison;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | use Tempest\Highlight\Languages\Ellison\Injections\ParserInjection;
 9 | 
10 | class EllisonLanguage extends BaseLanguage
11 | {
12 |     public function getName(): string
13 |     {
14 |         return 'ellison';
15 |     }
16 | 
17 |     public function getInjections(): array
18 |     {
19 |         return [
20 |             ...parent::getInjections(),
21 |             new ParserInjection(),
22 |         ];
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/NamedArgumentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class NamedArgumentPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(?<match>[\w]+):\s';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/NamespacePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class NamespacePattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return 'namespace (?<match>[\w\\\\]+)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::TYPE;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PropertyAccessPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PropertyAccessPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '->(?<match>[\w]+)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyCommentPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(^|[^\\\\])(?<match>#.*)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::COMMENT;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ConstantPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class ConstantPropertyPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '\:\:(?<match>[\w]+)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/FunctionCallPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class FunctionCallPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '\b(?<match>[a-z][\w]+)\(';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/FunctionNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class FunctionNamePattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return 'function (?<match>[\w]+)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/SinglelineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class SinglelineCommentPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(?<match>\/\/(.)*)';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::COMMENT;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Fast, extensible, server-side code highlighting
 2 | [![Coverage Status](https://coveralls.io/repos/github/tempestphp/highlight/badge.svg?branch=main)](https://coveralls.io/github/tempestphp/highlight?branch=main)
 3 | 
 4 | ## Quickstart
 5 | 
 6 | ```php
 7 | composer require tempest/highlight
 8 | ```
 9 | 
10 | Highlight code like this:
11 | 
12 | ```php
13 | $highlighter = new \Tempest\Highlight\Highlighter();
14 | 
15 | $code = $highlighter->parse($code, 'php');
16 | ```
17 | 
18 | Continue reading in the docs: [https://tempestphp.com/docs/highlight/01-getting-started](https://tempestphp.com/docs/highlight/01-getting-started).
19 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyArgumentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyArgumentPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(?<=,|\()\s*(?<match>\w+)s*=';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::VARIABLE;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/NestedFunctionCallPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class NestedFunctionCallPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(\s|\()(?<match>[\w]+)\(';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::PROPERTY;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/UsePatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\UsePattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class UsePatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new UsePattern(),
19 |             content: 'use Foo\Bar\Baz;',
20 |             expected: 'Foo\Bar\Baz',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/targets/ellison.md:
--------------------------------------------------------------------------------
 1 | ```ellison
 2 | The app highlights lengthy, complex sentences and common errors; if you see a yellow sentence, shorten or split it. If you see a red highlight, your sentence is so dense and complicated that your readers will get lost trying to follow its meandering, splitting logic — try editing this sentence to remove the red.
 3 | 
 4 | You can utilize a shorter word in place of a purple one. Click on highlights to fix them.
 5 | 
 6 | Adverbs and weakening phrases are helpfully shown in blue. Get rid of them and pick words with force, perhaps.
 7 | 
 8 | Phrases in green have been marked to show passive voice. 
 9 | ```
10 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyLogicalValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyLogicalValuePattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '\b(?<match>(?:False|None|True))\b';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::LITERAL;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/ExtendsPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\ExtendsPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class ExtendsPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new ExtendsPattern(),
19 |             content: 'class Foo extends Bar',
20 |             expected: 'Bar',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/FunctionCallPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\FunctionCallPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class FunctionCallPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new FunctionCallPattern(),
19 |             content: 'foo()',
20 |             expected: 'foo',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/MultilineSingleDocCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class MultilineSingleDocCommentPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '/(?<match>\/\*(.|\n)*?\*\/)/m';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::COMMENT;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyTripleDoubleQuoteStringPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyTripleDoubleQuoteStringPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '/(?<match>"""(.|\n)*?""")/m';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::VALUE;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/NamespacePatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\NamespacePattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class NamespacePatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new NamespacePattern(),
19 |             content: 'namespace Foo\Bar',
20 |             expected: 'Foo\Bar',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyTripleSingleQuoteStringPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyTripleSingleQuoteStringPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '/(?<match>\'\'\'(.|\n)*?\'\'\')/m';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::VALUE;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/FunctionNamePatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\FunctionNamePattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class FunctionNamePatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new FunctionNamePattern(),
19 |             content: 'function foo()',
20 |             expected: 'foo',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Injections/BladeEchoInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class BladeEchoInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '({{(?!--))(?<match>.*)(}})';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Html/Injections/PhpInHtmlInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class PhpInHtmlInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '\<\?php(?<match>(.|\n)*?)\?>';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Injections/BladePhpInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class BladePhpInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '\@php(?<match>(.|\n)*?)\@endphp';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Injections/BladeRawEchoInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class BladeRawEchoInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '({!!)(?<match>.*)(!!})';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyOperatorPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyOperatorPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return "(?<match>([-+&%=]=?|!=|:=|>>=|<<=|\|=|\^=|\*\*?=?|\/\/?=?|<[<=]?|>[=>]?|[\|^~]))";
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::OPERATOR;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Injections/BladeKeywordInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class BladeKeywordInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(\@[\w]+)\s?\((?<match>.*)\)';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Html/Injections/CssInHtmlInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class CssInHtmlInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '<style>(?<match>(.|\n)*?)<\/style>';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'css');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/SinglelineDocCommentPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\SinglelineCommentPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class SinglelineDocCommentPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new SinglelineCommentPattern(),
19 |             content: '$bar // foo',
20 |             expected: '// foo',
21 |         );
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Themes/LightTerminalThemeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Themes;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Escape;
 9 | use Tempest\Highlight\Highlighter;
10 | use Tempest\Highlight\Themes\LightTerminalTheme;
11 | 
12 | class LightTerminalThemeTest extends TestCase
13 | {
14 |     public function test_injection_tokens_are_filtered(): void
15 |     {
16 |         $highlighter = new Highlighter(new LightTerminalTheme());
17 | 
18 |         $parsed = $highlighter->parse('{~}): Foo {}~}', 'php');
19 | 
20 |         $this->assertStringNotContainsString(Escape::INJECTION_TOKEN, $parsed);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Languages/Html/Injections/PhpShortEchoInHtmlInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class PhpShortEchoInHtmlInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '/<\?=\s(?<match>.*)\s\?>/';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'php');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Html/Injections/CssAttributeInHtmlInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | 
11 | final readonly class CssAttributeInHtmlInjection implements Injection
12 | {
13 |     use IsInjection;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return 'style="(?<match>(.|\n)*?)"';
18 |     }
19 | 
20 |     public function parseContent(string $content, Highlighter $highlighter): string
21 |     {
22 |         return $highlighter->parse($content, 'css');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpCloseTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '?>', output: '?>')]
13 | final readonly class PhpCloseTagPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\?\>+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::KEYWORD;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/VariablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '$foo', output: '$foo')]
13 | final readonly class VariablePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\\$[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VARIABLE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ExtendsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'extends Foo', output: 'Foo')]
13 | final readonly class ExtendsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'extends\s(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Patterns/InjectionTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Patterns;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\IsPattern;
 9 | use Tempest\Highlight\Pattern;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | final readonly class InjectionTokenPattern implements Pattern
13 | {
14 |     use IsPattern;
15 | 
16 |     public function getPattern(): string
17 |     {
18 |         return Escape::INJECTION_TOKEN . '(?<match>(.|\n)*?)' . Escape::INJECTION_TOKEN;
19 |     }
20 | 
21 |     public function getTokenType(): TokenTypeEnum
22 |     {
23 |         return TokenTypeEnum::INJECTION;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigKeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class TwigKeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private string $keyword)
16 |     {
17 |     }
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return "\b(?<match>{$this->keyword})\b";
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::KEYWORD;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssImportPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: "@import main.css", output: '@import')]
13 | final readonly class CssImportPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\@import)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::KEYWORD;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/ExtendsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'extends Foo', output: 'Foo')]
13 | final readonly class ExtendsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'extends\s(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ShortFunctionReferencePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'fn&() =>', output: 'fn')]
13 | final class ShortFunctionReferencePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return "(?<match>fn)\&";
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::KEYWORD;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigMethodPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'calcArea() {', output: 'calcArea')]
13 | final readonly class TwigMethodPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>[\w]+)\(';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Object.foo()', output: 'foo')]
13 | final readonly class TwigPropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\.(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '# comment', output: '# comment')]
13 | final readonly class YamlCommentPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\#(.)*)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::COMMENT;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/KeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class KeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private readonly string $keyword)
16 |     {
17 |     }
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return "/\b(?<match>{$this->keyword})\b/";
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::KEYWORD;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ClassResolutionPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '$foo::class', output: 'class')]
13 | final readonly class ClassResolutionPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\:\:(?<match>class)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::KEYWORD;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/OperatorPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class OperatorPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private string $operator)
16 |     {
17 |     }
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return "/\s(?<!\\$)(?<match>{$this->operator})(\s|\()/";
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::OPERATOR;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigFilterPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: " 'Search'|trans ", output: 'trans')]
13 | final readonly class TwigFilterPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\|(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/DocComment/Patterns/DocCommentTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\DocComment\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@param', output: '@param')]
13 | final readonly class DocCommentTagPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\@[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/AsTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'as int', output: 'int')]
13 | final readonly class AsTypePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'as\s+\b(?<match>[a-zA-Z][a-zA-Z0-9]+)\b';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/ClassNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'class_name Foo', output: 'Foo')]
13 | final readonly class ClassNamePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'class_name\s(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/FunctionNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'func foo()', output: 'foo')]
13 | final readonly class FunctionNamePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'func (?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/SinglelineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '# foo', output: '# foo')]
13 | final readonly class SinglelineCommentPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>#(.)*)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::COMMENT;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsMethodPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'calcArea() {', output: 'calcArea')]
13 | final readonly class JsMethodPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>[\w]+)\(';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Object.foo()', output: 'foo')]
13 | final readonly class JsPropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\.(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Json/Patterns/JsonAccoladesPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Json\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '{"foo":"bar"}', output: ['{', '}'])]
13 | final readonly class JsonAccoladesPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>(\{|\}))';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Json/Patterns/JsonDoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Json\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '"baz"', output: '"baz"')]
13 | final readonly class JsonDoubleQuoteValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\".*?\")';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlDoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'bar = "baz"', output: 'baz')]
13 | final readonly class SqlDoubleQuoteValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\"(?<match>.*?)\"';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlSingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: "bar = 'baz'", output: 'baz')]
13 | final readonly class SqlSingleQuoteValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\'(?<match>.*?)\'';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigNamedArgumentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('data_uri(mime="text/html",', 'mime')]
13 | final readonly class TwigNamedArgumentPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>[\w]+)\=';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlDoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'bar: "baz"', output: 'baz')]
13 | final readonly class YamlDoubleQuoteValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\"(?<match>.*?)\"';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlSingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: "bar: 'baz'", output: 'baz')]
13 | final readonly class YamlSingleQuoteValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\'(?<match>.*?)\'';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/PropertyAccessPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'foo.bar', output: 'bar')]
13 | final readonly class PropertyAccessPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '[\w]+\.(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Json/Patterns/JsonPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Json\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '"baz": "bar"', output: '"baz"')]
13 | final readonly class JsonPropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\"[\w\\\-]+\")(\s)*\:';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::KEYWORD;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlTablePropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'SELECT country.name', output: 'name')]
13 | final readonly class SqlTablePropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\.(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlDashPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '- name: Setup problem matchers |', output: '-')]
13 | final readonly class YamlDashPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '/^[\s]*(?<match>-)/m';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Diff/DiffLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Diff;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | use Tempest\Highlight\Languages\Diff\Injections\DiffAdditionInjection;
 9 | use Tempest\Highlight\Languages\Diff\Injections\DiffDeletionInjection;
10 | 
11 | class DiffLanguage extends BaseLanguage
12 | {
13 |     public function getName(): string
14 |     {
15 |         return 'diff';
16 |     }
17 | 
18 |     public function getInjections(): array
19 |     {
20 |         return [
21 |             ...parent::getInjections(),
22 |             new DiffAdditionInjection(),
23 |             new DiffDeletionInjection(),
24 |         ];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Dockerfile/Patterns/KeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Dockerfile\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class KeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private string $keyword)
16 |     {
17 |     }
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return "/^[\s]*(?<match>{$this->keyword})[\s].*/m";
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::KEYWORD;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsClassNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'class Rectangle', output: 'Rectangle')]
13 | final readonly class JsClassNamePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'class (?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Json/Patterns/JsonArrayBracketsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Json\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '"foo": ["bar"]', output: ['[', ']'])]
13 | final readonly class JsonArrayBracketsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>(\[|\]))';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlTableAccessPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'SELECT country.country_name_eng', output: 'country')]
13 | final readonly class SqlTableAccessPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>[\w]+)\.';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlArrayBracketsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'branches: [main]', output: ['[', ']'])]
13 | final readonly class YamlArrayBracketsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>(\[|\]))';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlPipePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '- name: Setup problem matchers |', output: '|')]
13 | final readonly class YamlPipePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '/^[-\s\w\:]+(?<match>\|)/m';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsStaticPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'static foo', output: 'foo')]
13 | final readonly class JsStaticPropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'static (?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyFunctionPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'def fibonacci(n)', output: 'fibonacci')]
13 | final readonly class PyFunctionPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\bdef\s+(?<match>\w*)(?=\s*\()';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'SELECT foo, bar, c.baz', output:['foo', 'bar'])]
13 | final readonly class SqlPropertyPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(SELECT|,)\s(?<match>(\w)+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/GenericPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class GenericPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(
16 |         private string $pattern,
17 |         private TokenTypeEnum $tokenType,
18 |     ) {
19 |     }
20 | 
21 |     public function getPattern(): string
22 |     {
23 |         return $this->pattern;
24 |     }
25 | 
26 |     public function getTokenType(): TokenTypeEnum
27 |     {
28 |         return $this->tokenType;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsSinglelineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '// language', output: '// language')]
13 | final readonly class JsSinglelineCommentPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\/\/(.)*)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::COMMENT;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentTemplateTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@template T', output: 'T')]
13 | final readonly class PhpDocCommentTemplateTypePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\@template(\s)+(?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::GENERIC;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigArrayKeyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest("'item-1': {", "'item-1'")]
13 | #[PatternTest('item: {', 'item')]
14 | final readonly class TwigArrayKeyPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>[\w\-\'\"]+)\:';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlVariablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'runs-on: ${{ matrix.os }}', output: ' matrix.os ')]
13 | final readonly class YamlVariablePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\\$\{\{(?<match>[\w\s\.]+)\}\}';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/Themes/TerminalThemeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Themes;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Themes\LightTerminalTheme;
10 | 
11 | class TerminalThemeTest extends TestCase
12 | {
13 |     public function test_terminal_theme()
14 |     {
15 |         $content = <<<TXT
16 | public function before
17 | TXT;
18 | 
19 |         $highlighter = new Highlighter(new LightTerminalTheme());
20 | 
21 |         $output = $highlighter->parse($content, 'php');
22 | 
23 |         $this->assertSame(
24 |             "\e[34mpublic\e[0m \e[34mfunction\e[0m \e[32mbefore\e[0m",
25 |             $output,
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/DoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'return "hello"',
14 |     output: 'hello',
15 | )]
16 | final readonly class DoubleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '"(?<match>.*?)"';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/DoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'return "hello"',
14 |     output: '"hello"',
15 | )]
16 | final readonly class DoubleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '(?<match>"(\\\"|.)*?")';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/UseFunctionNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('use function Tempest\redirect;', 'redirect')]
13 | final readonly class UseFunctionNamePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'use function [\w\\\\]+\\\\(?<match>[\w]+);';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/UseFunctionPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('use function Tempest\\Foo\\redirect;', 'Tempest\\Foo\\')]
13 | final readonly class UseFunctionPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'use function (?<match>[\w\\\\]+\\\\)[\w]+\;';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigDoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'return "hello"',
14 |     output: 'hello',
15 | )]
16 | final readonly class TwigDoubleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '"(?<match>.*?)"';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Patterns/AdditionEndTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\IgnoreTokenType;
11 | use Tempest\Highlight\Tokens\TokenType;
12 | 
13 | #[PatternTest('{+ pull_request_target: +}', '+}')]
14 | final readonly class AdditionEndTokenPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/(?<match>\+})/';
21 |     }
22 | 
23 |     public function getTokenType(): TokenType
24 |     {
25 |         return new IgnoreTokenType();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/SingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: "return 'hello';",
14 |     output: 'hello',
15 | )]
16 | final readonly class SingleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return "'(?<match>.*?)'";
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Injections/JsDocInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | use Tempest\Highlight\Languages\JavaScript\JsDocLanguage;
11 | 
12 | final readonly class JsDocInjection implements Injection
13 | {
14 |     use IsInjection;
15 | 
16 |     public function getPattern(): string
17 |     {
18 |         return '/(?<match>\/\*\*(.|\n)*?\*\/)/m';
19 |     }
20 | 
21 |     public function parseContent(string $content, Highlighter $highlighter): string
22 |     {
23 |         return $highlighter->parse($content, new JsDocLanguage());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/JsDocLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript;
 6 | 
 7 | use Tempest\Highlight\Languages\DocComment\DocCommentLanguage;
 8 | use Tempest\Highlight\Languages\JavaScript\Patterns\JsDocParamNamePattern;
 9 | use Tempest\Highlight\Languages\JavaScript\Patterns\JsDocTypePattern;
10 | 
11 | class JsDocLanguage extends DocCommentLanguage
12 | {
13 |     public function getName(): string
14 |     {
15 |         return 'jsdoc';
16 |     }
17 | 
18 |     public function getPatterns(): array
19 |     {
20 |         return [
21 |             ...parent::getPatterns(),
22 |             new JsDocTypePattern(),
23 |             new JsDocParamNamePattern(),
24 |         ];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentGenericTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@param class-string<T> $className', output: 'T')]
13 | final readonly class PhpDocCommentGenericTypePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '\<(?<match>[\w]+)\>';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::GENERIC;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpOpenTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '<?php', output: '<?php')]
13 | #[PatternTest(input: '<?=', output: '<?=')]
14 | final readonly class PhpOpenTagPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>\<\?[=|php]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::KEYWORD;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlSinglelineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '-- single-line comment', output: '-- single-line comment')]
13 | final readonly class SqlSinglelineCommentPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\-\-(.)*)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::COMMENT;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigSingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: "return 'hello';",
14 |     output: 'hello',
15 | )]
16 | final readonly class TwigSingleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return "'(?<match>.*?)'";
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlDoubleAccoladesValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'runs-on: ${{ matrix.os }}', output: ['{{', '}}'])]
13 | final readonly class YamlDoubleAccoladesValuePattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>(\{\{|\}\}))';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::VALUE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Patterns/AdditionStartTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\IgnoreTokenType;
11 | use Tempest\Highlight\Tokens\TokenType;
12 | 
13 | #[PatternTest('{+ pull_request_target: +}', '{+')]
14 | final readonly class AdditionStartTokenPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/(?<match>{\+)/';
21 |     }
22 | 
23 |     public function getTokenType(): TokenType
24 |     {
25 |         return new IgnoreTokenType();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/UseAsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('use Illuminate\Contracts\Container\Container as ContainerContract', 'ContainerContract')]
13 | final readonly class UseAsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return 'use [\w\\\\]+ as (?<match>[\w]+)';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::TYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyNumberPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyNumberPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function getPattern(): string
16 |     {
17 |         return '(?<match>\b0(?:[bB](?:_?[01])+|[oO](?:_?[0-7])+|[xX](?:_?[a-fA-F0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:[eE][+-]?\d+(?:_\d+)*)?j?(?!\w))';
18 |     }
19 | 
20 |     public function getTokenType(): TokenTypeEnum
21 |     {
22 |         return TokenTypeEnum::NUMBER;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class TwigTokenPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(
16 |         private readonly string $regex,
17 |         private readonly TokenTypeEnum $type,
18 |     ) {
19 |     }
20 | 
21 |     public function getPattern(): string
22 |     {
23 |         return "/(?<match>{$this->regex})/";
24 |     }
25 | 
26 |     public function getTokenType(): TokenTypeEnum
27 |     {
28 |         return $this->type;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Languages/Xml/Patterns/XmlCloseTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Xml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '</x-hello>', output: 'x-hello')]
13 | #[PatternTest(input: '</a>', output: 'a')]
14 | final readonly class XmlCloseTagPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '<\/(?<match>[\w\-]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::KEYWORD;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Patterns/BladeKeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: '@if()
14 |         @endif()',
15 |     output: ['@if', '@endif'],
16 | )]
17 | final readonly class BladeKeywordPattern implements Pattern
18 | {
19 |     use IsPattern;
20 | 
21 |     public function getPattern(): string
22 |     {
23 |         return '(?<match>\@[\w]+)\b';
24 |     }
25 | 
26 |     public function getTokenType(): TokenTypeEnum
27 |     {
28 |         return TokenTypeEnum::KEYWORD;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsObjectPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'prop: false,',
14 |     output: 'prop',
15 | )]
16 | final readonly class JsObjectPropertyPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '[\s]*(?<match>[\w]+)\:';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::PROPERTY;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Injections/PhpDocCommentInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | use Tempest\Highlight\Languages\Php\PhpDocCommentLanguage;
11 | 
12 | final readonly class PhpDocCommentInjection implements Injection
13 | {
14 |     use IsInjection;
15 | 
16 |     public function getPattern(): string
17 |     {
18 |         return '/(?<match>\/\*\*(.|\n)*?\*\/)/m';
19 |     }
20 | 
21 |     public function parseContent(string $content, Highlighter $highlighter): string
22 |     {
23 |         return $highlighter->parse($content, new PhpDocCommentLanguage());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlFunctionPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'COUNT(*)', output: 'COUNT')]
13 | #[PatternTest(input: 'count(*)', output: 'count')]
14 | final readonly class SqlFunctionPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/(?<match>[\w]+)\(/i';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/FunctionCallPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'foo()', output: 'foo')]
13 | #[PatternTest(input: '.foo()', output: 'foo')]
14 | final readonly class FunctionCallPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\b(?<match>[a-z][\w]+)\(';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/OperatorPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class OperatorPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private readonly string $operator)
16 |     {
17 |     }
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         $quoted = preg_quote($this->operator, '/');
22 | 
23 |         return "/(?<match>{$quoted})/";
24 |     }
25 | 
26 |     public function getTokenType(): TokenTypeEnum
27 |     {
28 |         return TokenTypeEnum::OPERATOR;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsDocTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('@param {string} foo ', '{string}')]
13 | #[PatternTest('@param {Object[]} foo', '{Object[]}')]
14 | final readonly class JsDocTypePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>\{(.*?)\})';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsDoubleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'return "hello"',
14 |     output: '"hello"',
15 | )]
16 | final readonly class JsDoubleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '(?<match>"(\\\"|.)*?")';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsSingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: "return 'hello';",
14 |     output: "'hello'",
15 | )]
16 | final readonly class JsSingleQuoteValuePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return "(?<match>'(\\\'|.)*?')";
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Patterns/BladeCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: '{{-- test --}} content',
14 |     output: '{{-- test --}}',
15 | )]
16 | final readonly class BladeCommentPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '(?<match>\{\{\-\-(.|\n)*?\-\-\}\})';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::COMMENT;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Html/Injections/JavaScriptInHtmlInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html\Injections;
 6 | 
 7 | use Tempest\Highlight\Highlighter;
 8 | use Tempest\Highlight\Injection;
 9 | use Tempest\Highlight\IsInjection;
10 | use Tempest\Highlight\Languages\JavaScript\JavaScriptLanguage;
11 | 
12 | final readonly class JavaScriptInHtmlInjection implements Injection
13 | {
14 |     use IsInjection;
15 | 
16 |     public function getPattern(): string
17 |     {
18 |         return '<script>(?<match>(.|\n)*)<\/script>';
19 |     }
20 | 
21 |     public function parseContent(string $content, Highlighter $highlighter): string
22 |     {
23 |         return $highlighter->parse($content, new JavaScriptLanguage());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/StaticPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Foo::$bar', output: '$bar')]
13 | #[PatternTest(input: 'new MyClass()::$bar', output: '$bar')]
14 | final readonly class StaticPropertyPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\:\:(?<match>\\$[\w]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlFromTablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM country', output: 'country')]
13 | #[PatternTest(input: 'from country', output: 'country')]
14 | final readonly class SqlFromTablePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/\bFROM (?<match>[\w]+)/i';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Injections/TwigEchoInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\IsInjection;
11 | use Tempest\Highlight\Languages\Twig\TwigEchoLanguage;
12 | 
13 | class TwigEchoInjection implements Injection
14 | {
15 |     use IsInjection;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>({{(.|\n)*?}}))';
20 |     }
21 | 
22 |     public function parseContent(string $content, Highlighter $highlighter): string
23 |     {
24 |         return Escape::injection($highlighter->parse($content, new TwigEchoLanguage()));
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Injections/TwigTagInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\IsInjection;
11 | use Tempest\Highlight\Languages\Twig\TwigTagLanguage;
12 | 
13 | class TwigTagInjection implements Injection
14 | {
15 |     use IsInjection;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>({%(.|\n)*?%}))';
20 |     }
21 | 
22 |     public function parseContent(string $content, Highlighter $highlighter): string
23 |     {
24 |         return Escape::injection($highlighter->parse($content, new TwigTagLanguage()));
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ImplementsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'implements Foo', output: ' Foo')]
13 | #[PatternTest(input: 'implements Foo, Bar', output: ' Foo, Bar')]
14 | final readonly class ImplementsPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return 'implements(?<match>[\s\,\w]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlAsTablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM country AS alias', output: 'alias')]
13 | #[PatternTest(input: 'from country as alias', output: 'alias')]
14 | final readonly class SqlAsTablePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/\bAS (?<match>[\w]+)/i';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/test-terminal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Tempest\Highlight\Highlighter;
 4 | use Tempest\Highlight\Themes\LightTerminalTheme;
 5 | 
 6 | require_once __DIR__ . '/vendor/autoload.php';
 7 | 
 8 | $highlighter = (new Highlighter(new LightTerminalTheme()))->withGutter();
 9 | 
10 | $target = $argc > 1
11 |     ? $argv[1]
12 |     : 'targets' . DIRECTORY_SEPARATOR . 'test.md';
13 | 
14 | $code = file_get_contents(__DIR__ . DIRECTORY_SEPARATOR . 'tests' . DIRECTORY_SEPARATOR . $target);
15 | 
16 | preg_match('/```(\w+)/', $code, $matches);
17 | 
18 | $language = count($matches) > 0
19 |     ? $matches[1]
20 |     : 'html';
21 | 
22 | $code = str_replace(
23 |     ['```' . $language, '```'],
24 |     '',
25 |     $code,
26 | );
27 | 
28 | echo PHP_EOL, $highlighter->parse($code, $language), PHP_EOL, PHP_EOL;
29 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssVariablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '--var-name: foo', output: '--var-name')]
13 | #[PatternTest(input: 'var(--var-name)', output: '--var-name')]
14 | final readonly class CssVariablePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>\-\-[\w\-]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/DocComment/DocCommentLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\DocComment;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | use Tempest\Highlight\Languages\DocComment\Patterns\DocCommentTagPattern;
 9 | 
10 | class DocCommentLanguage extends BaseLanguage
11 | {
12 |     public function getName(): string
13 |     {
14 |         return 'doc';
15 |     }
16 | 
17 |     public function getInjections(): array
18 |     {
19 |         return [
20 |             ...parent::getInjections(),
21 |         ];
22 |     }
23 | 
24 |     public function getPatterns(): array
25 |     {
26 |         return [
27 |             ...parent::getPatterns(),
28 |             new DocCommentTagPattern(),
29 |         ];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsStaticClassPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Math.round', output: 'Math')]
13 | #[PatternTest(input: 'customHeaders.get', output: null)]
14 | final readonly class JsStaticClassPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\b(?<match>[A-Z][\w]+)\.';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlJoinTablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'INNER JOIN country', output: 'country')]
13 | #[PatternTest(input: 'inner join country', output: 'country')]
14 | final readonly class SqlJoinTablePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/\bJOIN (?<match>[\w]+)/i';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlObjectBracketsPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'branches: { link: "/blog/new-in-php-83", title: "Whats new in PHP 8.3" }', output: ['{', '}'])]
13 | final readonly class YamlObjectBracketsPattern implements Pattern
14 | {
15 |     use IsPattern;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>(\{|\}))';
20 |     }
21 | 
22 |     public function getTokenType(): TokenTypeEnum
23 |     {
24 |         return TokenTypeEnum::PROPERTY;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/ReturnTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'func foo()->Bar:', output: 'Bar')]
13 | #[PatternTest(input: 'func foo() -> Bar :', output: 'Bar')]
14 | final readonly class ReturnTypePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\)\s*\-\>\s*(?<match>.+?)[\s*:\n]';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/EnumBackedTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'enum Foo: string', output: 'string')]
13 | #[PatternTest(input: 'enum Foo: int', output: 'int')]
14 | final readonly class EnumBackedTypePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return 'enum [\w]+\:(\s)*(?<match>int|string)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'name: Fix Styling', output: 'name')]
13 | #[PatternTest(input: 'property-name: value', output: 'property-name')]
14 | final readonly class YamlPropertyPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>[\w-]+)\:';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::KEYWORD;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/InstanceOfPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'instanceof Closure', output: 'Closure')]
13 | #[PatternTest(input: 'instanceof \\Foo\\Bar', output: '\\Foo\\Bar')]
14 | final readonly class InstanceOfPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return 'instanceof\s(?<match>[\w\\\\]+)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsMultilineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'bla; /*
14 | hello
15 | */ foo',
16 |     output: '/*
17 | hello
18 | */'
19 | )]
20 | final readonly class JsMultilineCommentPattern implements Pattern
21 | {
22 |     use IsPattern;
23 | 
24 |     public function getPattern(): string
25 |     {
26 |         return '/(?<match>\/\*(.|\n)*?\*\/)/m';
27 |     }
28 | 
29 |     public function getTokenType(): TokenTypeEnum
30 |     {
31 |         return TokenTypeEnum::COMMENT;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyClassNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'class MyClass:', output: 'MyClass')]
13 | #[PatternTest(input: 'class HisClass(MyClass):', output: 'HisClass')]
14 | final readonly class PyClassNamePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\bclass\s+(?<match>\w*)(?=[\s*\:(])';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Sql/Patterns/SqlMultilineCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Sql\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: '/*
14 | multi-line comment
15 | */',
16 |     output: '/*
17 | multi-line comment
18 | */'
19 | )]
20 | final readonly class SqlMultilineCommentPattern implements Pattern
21 | {
22 |     use IsPattern;
23 | 
24 |     public function getPattern(): string
25 |     {
26 |         return '/(?<match>\/\*(.|\n)*?\*\/)/m';
27 |     }
28 | 
29 |     public function getTokenType(): TokenTypeEnum
30 |     {
31 |         return TokenTypeEnum::COMMENT;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Languages/Yaml/Patterns/YamlColonPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Yaml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '- name: Setup problem matchers |', output: ':')]
13 | #[PatternTest(input: '- { link: "/blog/new-in-php-83" }', output: ':')]
14 | final readonly class YamlColonPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '/^[\-\{\s\w]*(?<match>:)/m';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyDecoratorPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@decorator', output: '@decorator')]
13 | #[PatternTest(input: '@decorator.chained', output: '@decorator.chained')]
14 | final readonly class PyDecoratorPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(^|\n)\s*(?<match>@\s*\w*(?:\.\w+)*)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::PROPERTY;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Patterns/DeletionEndTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\IgnoreTokenType;
11 | use Tempest\Highlight\Tokens\TokenType;
12 | 
13 | #[PatternTest('{- pull_request_target: -}', '-}')]
14 | #[PatternTest('{-- pull_request_target: --}', null)]
15 | final readonly class DeletionEndTokenPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '/(?<!-)(?<match>\-})/';
22 |     }
23 | 
24 |     public function getTokenType(): TokenType
25 |     {
26 |         return new IgnoreTokenType();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsNewObjectPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'new Rectangle(', output: 'Rectangle')]
13 | #[PatternTest(input: 'new qq.AjaxRequester(', output: 'AjaxRequester')]
14 | final readonly class JsNewObjectPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return 'new (\w+\.)*(?<match>[\w]+)(\s)*\(';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Xml/Patterns/XmlOpenTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Xml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '<x-hello attr="">', output: 'x-hello')]
13 | #[PatternTest(input: '<a href="">', output: 'a')]
14 | #[PatternTest(input: '<br/>', output: 'br')]
15 | final readonly class XmlOpenTagPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '<(?<match>[\w\-]+)';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::KEYWORD;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Base/Patterns/DeletionStartTokenPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Base\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\IgnoreTokenType;
11 | use Tempest\Highlight\Tokens\TokenType;
12 | 
13 | #[PatternTest('{- pull_request_target: -}', '{-')]
14 | #[PatternTest('{-- pull_request_target: --}', null)]
15 | final readonly class DeletionStartTokenPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '/(?<match>{\-)(?!-)/';
22 |     }
23 | 
24 |     public function getTokenType(): TokenType
25 |     {
26 |         return new IgnoreTokenType();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Gdscript/Patterns/VarTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Gdscript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'var foo:int=', output: 'int')]
13 | #[PatternTest(input: 'var foo : int =', output: 'int')]
14 | #[PatternTest(input: 'foo : int', output: 'int')]
15 | final readonly class VarTypePattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '\:[^\S\n]*(?<match>\w+)';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::TYPE;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentReturnTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@return array|string', output: 'array|string')]
13 | #[PatternTest(input: '@return \\Foo', output: '\\Foo')]
14 | final readonly class PhpDocCommentReturnTypePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\@return(\s)+(?<match>.*?)(\*\/|$|\R)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Languages/Base/Injections/AdditionInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Base\Injections;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Escape;
 9 | use Tempest\Highlight\Highlighter;
10 | use Tempest\Highlight\Languages\Base\Injections\AdditionInjection;
11 | 
12 | class AdditionInjectionTest extends TestCase
13 | {
14 |     public function test_addition_injection()
15 |     {
16 |         $content = <<<TXT
17 | {+class Foo+}
18 | TXT;
19 | 
20 |         $expected = <<<TXT
21 | <span class="hl-addition">class Foo</span>
22 | TXT;
23 | 
24 |         $parsedInjection = (new AdditionInjection())->parse($content, new Highlighter());
25 | 
26 |         $this->assertSame($expected, Escape::html($parsedInjection->content));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Languages/Base/Injections/DeletionInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Base\Injections;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Escape;
 9 | use Tempest\Highlight\Highlighter;
10 | use Tempest\Highlight\Languages\Base\Injections\DeletionInjection;
11 | 
12 | class DeletionInjectionTest extends TestCase
13 | {
14 |     public function test_deletion_injection()
15 |     {
16 |         $content = <<<TXT
17 | {-class Foo-}
18 | TXT;
19 | 
20 |         $expected = <<<TXT
21 | <span class="hl-deletion">class Foo</span>
22 | TXT;
23 | 
24 |         $parsedInjection = (new DeletionInjection())->parse($content, new Highlighter());
25 | 
26 |         $this->assertSame($expected, Escape::html($parsedInjection->content));
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Languages/Blade/Injections/BladeEchoInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Blade\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Languages\Blade\Injections\BladeEchoInjection;
10 | use Tempest\Highlight\Tests\TestsInjections;
11 | 
12 | class BladeEchoInjectionTest extends TestCase
13 | {
14 |     use TestsInjections;
15 | 
16 |     #[Test]
17 |     public function test_injection(): void
18 |     {
19 |         $this->assertMatches(
20 |             injection: new BladeEchoInjection(),
21 |             content: '{{ count($foo) }}',
22 |             expectedContent: '{{ <span class="hl-property">count</span>(<span class="hl-variable">$foo</span>) }}',
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit
 3 |         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.2/phpunit.xsd"
 5 |         bootstrap="vendor/autoload.php"
 6 |         colors="true"
 7 |         displayDetailsOnTestsThatTriggerDeprecations="true"
 8 |         displayDetailsOnTestsThatTriggerErrors="true"
 9 |         displayDetailsOnTestsThatTriggerNotices="true"
10 |         displayDetailsOnTestsThatTriggerWarnings="true"
11 | >
12 |   <testsuites>
13 |     <testsuite name="Unit">
14 |       <directory suffix="Test.php">./tests</directory>
15 |     </testsuite>
16 |   </testsuites>
17 |   <coverage/>
18 |   <source>
19 |     <include>
20 |       <directory suffix=".php">./src</directory>
21 |     </include>
22 |   </source>
23 | </phpunit>
24 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentParamTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@param array|string $concrete', output: 'array|string')]
13 | #[PatternTest(input: '@param \\Foo $concrete', output: '\\Foo')]
14 | final readonly class PhpDocCommentParamTypePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\@param(\s)+(?<match>.*?) \\$';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/TokenTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Tokens\Token;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | class TokenTest extends TestCase
13 | {
14 |     #[Test]
15 |     public function test_contains(): void
16 |     {
17 |         $a = new Token(
18 |             offset: 10,
19 |             value: 'abc',
20 |             type: TokenTypeEnum::VALUE,
21 |         );
22 | 
23 |         $b = new Token(
24 |             offset: 11,
25 |             value: 'b',
26 |             type: TokenTypeEnum::VALUE,
27 |         );
28 | 
29 |         $this->assertTrue($a->containsOrOverlaps($b));
30 |         $this->assertFalse($b->containsOrOverlaps($a));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/StaticClassCallPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Foo::bar()', output: 'Foo')]
13 | #[PatternTest(input: 'Foo::BAR', output: 'Foo')]
14 | #[PatternTest(input: 'Foo\\Bar::BAR', output: 'Foo\\Bar')]
15 | final readonly class StaticClassCallPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '(?<!\\$)(?<match>[\\\\\w]+)\:\:';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::TYPE;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/Patterns/TwigCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'bla; {#
14 | hello
15 | #} foo',
16 |     output: '{#
17 | hello
18 | #}'
19 | )]
20 | #[PatternTest(input: '<tag>{# foo #}</tag>', output: '{# foo #}')]
21 | final readonly class TwigCommentPattern implements Pattern
22 | {
23 |     use IsPattern;
24 | 
25 |     public function getPattern(): string
26 |     {
27 |         return '(?<match>\{#(.|\n)*?#})';
28 |     }
29 | 
30 |     public function getTokenType(): TokenTypeEnum
31 |     {
32 |         return TokenTypeEnum::COMMENT;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Languages/Xml/Patterns/XmlAttributePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Xml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '<x-hello attr="">', output: 'attr')]
13 | #[PatternTest(input: '<a href="">', output: 'href')]
14 | #[PatternTest(input: '<a data-type="">', output: 'data-type')]
15 | final readonly class XmlAttributePattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '(?<match>[\w\-]+)="';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::PROPERTY;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/CatchTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'catch (Foo) {}', output: 'Foo')]
13 | #[PatternTest(input: 'catch (Foo|Bar) {}', output: 'Foo|Bar')]
14 | #[PatternTest(input: 'catch (Foo|Bar $bar) {}', output: null)]
15 | final readonly class CatchTypePattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return 'catch \((?<match>[\w\||]+)\)';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::TYPE;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/GroupedTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '(Foo&Bar)|null $bar', output: '(Foo&Bar)')]
13 | #[PatternTest(input: 'null|(Foo&Bar) $bar', output: '(Foo&Bar)')]
14 | #[PatternTest(input: 'while (true)', output: null)]
15 | final readonly class GroupedTypePattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '(?<match>\(\w+(&\w+)+\))';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::TYPE;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Languages/Blade/Injections/BladeRawEchoInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Blade\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Languages\Blade\Injections\BladeRawEchoInjection;
10 | use Tempest\Highlight\Tests\TestsInjections;
11 | 
12 | class BladeRawEchoInjectionTest extends TestCase
13 | {
14 |     use TestsInjections;
15 | 
16 |     #[Test]
17 |     public function test_injection_raw_echo(): void
18 |     {
19 |         $this->assertMatches(
20 |             injection: new BladeRawEchoInjection(),
21 |             content: '{!! count($foo) !!}',
22 |             expectedContent: '{!! <span class="hl-property">count</span>(<span class="hl-variable">$foo</span>) !!}',
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Languages/Css/Injections/CssAttributeInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Css\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Languages\Html\Injections\CssAttributeInHtmlInjection;
10 | use Tempest\Highlight\Tests\TestsInjections;
11 | 
12 | class CssAttributeInjectionTest extends TestCase
13 | {
14 |     use TestsInjections;
15 | 
16 |     #[Test]
17 |     public function test_injection(): void
18 |     {
19 |         $this->assertMatches(
20 |             injection: new CssAttributeInHtmlInjection(),
21 |             content: '<x-slot style="color: green">',
22 |             expectedContent: '&lt;x-slot style=&quot;<span class="hl-property">color</span>: green&quot;&gt;'
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/ClassNamePatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\ClassNamePattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class ClassNamePatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new ClassNamePattern(),
19 |             content: 'class Foo implements Bar',
20 |             expected: 'Foo',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new ClassNamePattern(),
25 |             content: 'interface Foo implements Bar',
26 |             expected: 'Foo',
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/ConstantPropertyPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\ConstantPropertyPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class ConstantPropertyPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new ConstantPropertyPattern(),
19 |             content: 'Foo::BAR',
20 |             expected: 'BAR',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new ConstantPropertyPattern(),
25 |             content: 'Foo::BAR()',
26 |             expected: 'BAR',
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: '    /* 1 */
14 |     font-feature-settings: normal;
15 |     /* 2 */
16 |     font-variation-settings: normal;',
17 |     output: ['/* 1 */', '/* 2 */'],
18 | )]
19 | final readonly class CssCommentPattern implements Pattern
20 | {
21 |     use IsPattern;
22 | 
23 |     public function getPattern(): string
24 |     {
25 |         return '/(?<match>\/\*(.|\n)*?\*\/)/m';
26 |     }
27 | 
28 |     public function getTokenType(): TokenTypeEnum
29 |     {
30 |         return TokenTypeEnum::COMMENT;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentReturnTypeSingleLinePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '/** @return array|string */', output: 'array|string')]
13 | #[PatternTest(input: '/** @return \\Foo */', output: '\\Foo')]
14 | final readonly class PhpDocCommentReturnTypeSingleLinePattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '\@return\s*(?<match>.*?)(\s*\*\/|$)';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::TYPE;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/NestedFunctionCallPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\NestedFunctionCallPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class NestedFunctionCallPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new NestedFunctionCallPattern(),
19 |             content: ' foo()',
20 |             expected: 'foo',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new NestedFunctionCallPattern(),
25 |             content: '(foo()',
26 |             expected: 'foo',
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Diff/Injections/DiffAdditionInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Diff\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\ParsedInjection;
10 | 
11 | class DiffAdditionInjection
12 | {
13 |     public function parse(string $content, Highlighter $highlighter): ParsedInjection
14 |     {
15 |         $content = preg_replace_callback(
16 |             '/^\+(.*)$/m',
17 |             function ($matches) {
18 |                 $open = Escape::tokens('<span class="hl-addition">+ ');
19 |                 $close = Escape::tokens('</span>');
20 | 
21 |                 return $open . $matches[1] . $close;
22 |             },
23 |             $content
24 |         );
25 | 
26 |         return new ParsedInjection($content);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/MultilineSingleDocCommentPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\MultilineSingleDocCommentPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class MultilineSingleDocCommentPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new MultilineSingleDocCommentPattern(),
19 |             content: '
20 | use Tempest\Highlight\Token;
21 | 
22 | /* world
23 |  * hello
24 |  */
25 | final class PhpLanguage implements Language
26 |             ',
27 |             expected: '/* world
28 |  * hello
29 |  */',
30 |         );
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/NewObjectPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'new Foo()', output: 'Foo')]
13 | #[PatternTest(input: 'new Foo\Bar()', output: 'Foo\Bar')]
14 | #[PatternTest(input: '(new Foo)', output: 'Foo')]
15 | #[PatternTest(input: 'new Foo', output: 'Foo')]
16 | final readonly class NewObjectPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return 'new (?<match>[\w\\\\]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::TYPE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/UntypedClassPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'private $foo', output: '$foo')]
13 | #[PatternTest(input: 'protected $foo', output: '$foo')]
14 | #[PatternTest(input: 'public $foo', output: '$foo')]
15 | final readonly class UntypedClassPropertyPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return '(public|private|protected)\s(?<match>\\$[\w]+)';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::PROPERTY;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Languages/Twig/Injections/TwigEchoInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Twig\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Languages\Twig\Injections\TwigEchoInjection;
10 | use Tempest\Highlight\Tests\TestsInjections;
11 | 
12 | class TwigEchoInjectionTest extends TestCase
13 | {
14 |     use TestsInjections;
15 | 
16 |     #[Test]
17 |     public function test_injection(): void
18 |     {
19 |         $content = '<b>Version</b> {{ appVersion }}';
20 | 
21 |         $expected = '&lt;b&gt;Version&lt;/b&gt; {{ appVersion }}';
22 | 
23 |         $this->assertMatches(
24 |             injection: new TwigEchoInjection(),
25 |             content: $content,
26 |             expectedContent: $expected,
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PropertyHookSetParameterTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenType;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | #[PatternTest('set (string $value', 'string')]
14 | #[PatternTest('set(string $value', 'string')]
15 | #[PatternTest('set(Author $value', 'Author')]
16 | final readonly class PropertyHookSetParameterTypePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return 'set\s*\((?<match>[\w]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenType
26 |     {
27 |         return TokenTypeEnum::TYPE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssAttributePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: '.hl-comment {
14 |         color: #888888;
15 |         font-style: italic;
16 |         font-family: "Radon", serif;
17 |     }',
18 |     output: ['color', 'font-style', 'font-family'],
19 | )]
20 | final readonly class CssAttributePattern implements Pattern
21 | {
22 |     use IsPattern;
23 | 
24 |     public function getPattern(): string
25 |     {
26 |         return '(?<match>[\w\-]+):';
27 |     }
28 | 
29 |     public function getTokenType(): TokenTypeEnum
30 |     {
31 |         return TokenTypeEnum::PROPERTY;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Injections/PhpFunctionParametersInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\IsInjection;
11 | use Tempest\Highlight\Languages\Php\PhpTypeLanguage;
12 | 
13 | final readonly class PhpFunctionParametersInjection implements Injection
14 | {
15 |     use IsInjection;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(function|fn)[\s\w]*\((?<match>(.|\n)*?)({|\)[\s]*({|;|:|=>))';
20 |     }
21 | 
22 |     public function parseContent(string $content, Highlighter $highlighter): string
23 |     {
24 |         return Escape::injection(
25 |             $highlighter->parse($content, new PhpTypeLanguage())
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/EnumCasePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'case Foo = "";', output: 'Foo')]
13 | #[PatternTest(input: 'case Foo="";', output: 'Foo')]
14 | #[PatternTest(input: 'case Foo;', output: 'Foo')]
15 | #[PatternTest(input: 'case Foo ;', output: 'Foo')]
16 | final readonly class EnumCasePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return 'case (?<match>[\w]+)(\s)*(=|;)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::PROPERTY;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ParsedInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | /*
 8 |  * A `ParsedInjection` is the result of an injection parsing content.
 9 |  * It contains the new content, as well as a list of tokens to be parsed
10 |  *
11 |  * The list of tokens returned from a ParsedInjection will be added
12 |  * to all other tokens detected by patterns, and thus follow all token rules.
13 |  * They are grouped and checked on whether tokens can be contained by other tokens.
14 |  * This offers more flexibility from the injection's point of view, and in same cases lead to more accurate highlighting.
15 |  */
16 | final readonly class ParsedInjection
17 | {
18 |     public function __construct(
19 |         public string $content,
20 |         /** @var \Tempest\Highlight\Tokens\Token[] */
21 |         public array $tokens = [],
22 |     ) {
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ConstantTypesPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'const string BAR_FOO = \'baz\'', output: 'string')]
13 | #[PatternTest(input: 'const BAR = \'baz\'', output: null)]
14 | #[PatternTest(input: 'const (Foo&Bar)|null BAR = \'baz\'', output: '(Foo&Bar)|null')]
15 | final readonly class ConstantTypesPattern implements Pattern
16 | {
17 |     use IsPattern;
18 | 
19 |     public function getPattern(): string
20 |     {
21 |         return 'const\s(?<match>.+?)\s[\w]+\s=';
22 |     }
23 | 
24 |     public function getTokenType(): TokenTypeEnum
25 |     {
26 |         return TokenTypeEnum::TYPE;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ClassNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'class Foo {}', output: 'Foo')]
13 | #[PatternTest(input: 'interface Foo {}', output: 'Foo')]
14 | #[PatternTest(input: 'trait Foo {}', output: 'Foo')]
15 | #[PatternTest(input: 'enum Foo {}', output: 'Foo')]
16 | final readonly class ClassNamePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '(class|interface|trait|enum) (?<match>[\w]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::TYPE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Languages/Twig/Patterns/TwigKeywordPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Twig\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Twig\Patterns\TwigKeywordPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class TwigKeywordPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new TwigKeywordPattern("extends"),
19 |             content: "{% extends 'admin/empty_base.html.twig' %}",
20 |             expected: 'extends',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new TwigKeywordPattern("if"),
25 |             content: "{% if is_granted('IS_IMPERSONATOR') %}",
26 |             expected: 'if',
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Languages/Blade/Injections/BladeKeywordInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Blade\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | use Tempest\Highlight\Languages\Blade\Injections\BladeKeywordInjection;
11 | 
12 | class BladeKeywordInjectionTest extends TestCase
13 | {
14 |     #[Test]
15 |     public function test_injection(): void
16 |     {
17 |         $content = '@if(count($foo))';
18 | 
19 |         $highlighter = new Highlighter();
20 |         $injection = new BladeKeywordInjection();
21 | 
22 |         $parsedInjection = $injection->parse($content, $highlighter);
23 | 
24 |         $this->assertStringContainsString(
25 |             '<span class="hl-property">count',
26 |             $parsedInjection->content,
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssFunctionPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'src: url("fonts/MonaspaceArgon-Bold.woff") format("woff");',
14 |     output: ['url', 'format'],
15 | )]
16 | 
17 | #[PatternTest(
18 |     input: 'background: linear-gradient(white 30%)',
19 |     output: ['linear-gradient'],
20 | )]
21 | final readonly class CssFunctionPattern implements Pattern
22 | {
23 |     use IsPattern;
24 | 
25 |     public function getPattern(): string
26 |     {
27 |         return '(?<match>[\w\-]+)\(';
28 |     }
29 | 
30 |     public function getTokenType(): TokenTypeEnum
31 |     {
32 |         return TokenTypeEnum::KEYWORD;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssMediaQueryPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@media only screen and (max-width: 500px) {', output: '@media only screen and (max-width: 500px) ')]
13 | #[PatternTest(input: '@media (min-width: 30em) and (max-width: 50em) {', output: '@media (min-width: 30em) and (max-width: 50em) ')]
14 | final readonly class CssMediaQueryPattern implements Pattern
15 | {
16 |     use IsPattern;
17 | 
18 |     public function getPattern(): string
19 |     {
20 |         return '(?<match>\@media(.*)?){';
21 |     }
22 | 
23 |     public function getTokenType(): TokenTypeEnum
24 |     {
25 |         return TokenTypeEnum::KEYWORD;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Languages/Text/TextLanguageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Text;
 6 | 
 7 | use PHPUnit\Framework\Attributes\DataProvider;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | 
11 | class TextLanguageTest extends TestCase
12 | {
13 |     #[DataProvider('data')]
14 |     public function test_highlight(string $content, string $expected): void
15 |     {
16 |         $highlighter = new Highlighter();
17 | 
18 |         $this->assertSame(
19 |             $expected,
20 |             $highlighter->parse($content, 'txt'),
21 |         );
22 | 
23 |         $this->assertSame(
24 |             $expected,
25 |             $highlighter->parse($content, 'text'),
26 |         );
27 |     }
28 | 
29 |     public static function data(): array
30 |     {
31 |         return [
32 |             ['test', 'test'],
33 |         ];
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Languages/Diff/Injections/DiffDeletionInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Diff\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\ParsedInjection;
10 | 
11 | class DiffDeletionInjection
12 | {
13 |     public function parse(string $content, Highlighter $highlighter): ParsedInjection
14 |     {
15 |         $content = preg_replace_callback(
16 |             '/^\-(.*)$/m', // Matches lines starting with '+'
17 |             function ($matches) {
18 |                 $open = Escape::tokens('<span class="hl-deletion">- ');
19 |                 $close = Escape::tokens('</span>');
20 | 
21 |                 return $open . $matches[1] . $close; // Wraps the matched line with the span
22 |             },
23 |             $content
24 |         );
25 | 
26 |         return new ParsedInjection($content);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PropertyHookGetPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenType;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | #[PatternTest(
14 |     '     public string $name {
15 |          get {',
16 |     'get'
17 | )]
18 | #[PatternTest(
19 |     '     public string $name {
20 |          get =>',
21 |     'get'
22 | )]
23 | #[PatternTest('get;', 'get')]
24 | final readonly class PropertyHookGetPattern implements Pattern
25 | {
26 |     use IsPattern;
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         return '(?<match>get)\s*({|=>|;)';
31 |     }
32 | 
33 |     public function getTokenType(): TokenType
34 |     {
35 |         return TokenTypeEnum::KEYWORD;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Languages/Blade/BladeLanguageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Blade;
 6 | 
 7 | use PHPUnit\Framework\Attributes\DataProvider;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | 
11 | class BladeLanguageTest extends TestCase
12 | {
13 |     #[DataProvider('data')]
14 |     public function test_highlight(string $content, string $expected): void
15 |     {
16 |         $highlighter = new Highlighter();
17 | 
18 |         $this->assertSame(
19 |             $expected,
20 |             $highlighter->parse($content, 'blade'),
21 |         );
22 |     }
23 | 
24 |     public static function data(): array
25 |     {
26 |         return [
27 |             ['{{-- Blade comment --}}', '<span class="hl-comment">{{-- Blade comment --}}</span>'],
28 |             ['{{-- if --}}', '<span class="hl-comment">{{-- if --}}</span>'],
29 |         ];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Patterns/BladeComponentCloseTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '</a>', output: 'a')]
13 | #[PatternTest(input: '</x-hello>', output: 'x-hello')]
14 | #[PatternTest(input: '</x-hello::world>', output: 'x-hello::world')]
15 | #[PatternTest(input: '</x-hello::world.lorem>', output: 'x-hello::world.lorem')]
16 | final readonly class BladeComponentCloseTagPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '<\/(?<match>[\w\-\:\.]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::KEYWORD;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsDocParamNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest('@param {string} foo ', 'foo')]
13 | #[PatternTest('@param {Object[]} foo', 'foo')]
14 | #[PatternTest('@param {string} employees[].name', 'employees[].name')]
15 | #[PatternTest('@param {string} employees[].name The name', 'employees[].name')]
16 | final readonly class JsDocParamNamePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '@param\s(.*?)\s(?<match>(.*?))(\s|$)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Dockerfile/Patterns/ImageAliasKeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Dockerfile\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM php', output: null)]
13 | #[PatternTest(input: 'FROM php:8.1', output: null)]
14 | #[PatternTest(input: 'FROM php:8.1 AS stage-one', output: 'AS')]
15 | #[PatternTest(input: ' FROM php:8.1 AS stage-one ', output: 'AS')]
16 | final readonly class ImageAliasKeywordPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return "/^[\s]*FROM[\s][\S]+[\s](?<match>AS)[\s][\S]+/m";
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::KEYWORD;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentVariablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@param array|string $concrete', output: '$concrete')]
13 | #[PatternTest(input: '@param $concrete', output: '$concrete')]
14 | #[PatternTest(input: '@var Foo $concrete', output: '$concrete')]
15 | #[PatternTest(input: '@var $concrete', output: '$concrete')]
16 | final readonly class PhpDocCommentVariablePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '(?<match>\\$[\w]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VARIABLE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Dockerfile/Patterns/ImageAliasNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Dockerfile\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM php', output: null)]
13 | #[PatternTest(input: 'FROM php:8.1', output: null)]
14 | #[PatternTest(input: 'FROM php:8.1 AS stage-one', output: 'stage-one')]
15 | #[PatternTest(input: ' FROM php:8.1 AS stage-one ', output: 'stage-one')]
16 | final readonly class ImageAliasNamePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return "/^[\s]*FROM[\s][\S]+[\s]AS[\s](?<match>[\S]+)/m";
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::VALUE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Languages/Blade/Injections/BladePhpInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Blade\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | use Tempest\Highlight\Languages\Blade\Injections\BladePhpInjection;
11 | 
12 | class BladePhpInjectionTest extends TestCase
13 | {
14 |     #[Test]
15 |     public function test_injection(): void
16 |     {
17 |         $content = '
18 |         @php
19 |         count($foo)
20 |         @endphp
21 |         ';
22 | 
23 |         $highlighter = new Highlighter();
24 |         $injection = new BladePhpInjection();
25 | 
26 |         $parsedInjection = $injection->parse($content, $highlighter);
27 | 
28 |         $this->assertStringContainsString(
29 |             '<span class="hl-property">count',
30 |             $parsedInjection->content,
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ConstantNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'int $pad_type = STR_PAD_RIGHT,',
14 |     output: 'STR_PAD_RIGHT',
15 | )]
16 | #[PatternTest(
17 |     input: 'private const BAR = "bar";',
18 |     output: 'BAR',
19 | )]
20 | #[PatternTest(
21 |     input: 'private const string BAR = ""',
22 |     output: 'BAR',
23 | )]
24 | final readonly class ConstantNamePattern implements Pattern
25 | {
26 |     use IsPattern;
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         return '\b(?<match>[A-Z_]+)\b';
31 |     }
32 | 
33 |     public function getTokenType(): TokenTypeEnum
34 |     {
35 |         return TokenTypeEnum::PROPERTY;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Languages/Twig/Patterns/TwigTokenPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Twig\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Twig\Patterns\TwigTokenPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | class TwigTokenPatternTest extends TestCase
13 | {
14 |     use TestsPatterns;
15 | 
16 |     public function test_pattern()
17 |     {
18 |         $this->assertMatches(
19 |             pattern: new TwigTokenPattern("^{%", TokenTypeEnum::TYPE),
20 |             content: "{% extends 'admin/empty_base.html.twig' %}",
21 |             expected: '{%',
22 |         );
23 | 
24 |         $this->assertMatches(
25 |             pattern: new TwigTokenPattern("}}$", TokenTypeEnum::TYPE),
26 |             content: "{{ path('app.logout') }}",
27 |             expected: '}}',
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/CommonMark/HighlightExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\CommonMark;
 6 | 
 7 | use League\CommonMark\Environment\EnvironmentBuilderInterface;
 8 | use League\CommonMark\Extension\CommonMark\Node\Block\FencedCode;
 9 | use League\CommonMark\Extension\CommonMark\Node\Inline\Code;
10 | use League\CommonMark\Extension\ExtensionInterface;
11 | use Tempest\Highlight\Highlighter;
12 | 
13 | final class HighlightExtension implements ExtensionInterface
14 | {
15 |     public function __construct(
16 |         private ?Highlighter $highlighter = new Highlighter(),
17 |     ) {
18 |     }
19 | 
20 |     public function register(EnvironmentBuilderInterface $environment): void
21 |     {
22 |         $environment
23 |             ->addRenderer(FencedCode::class, new CodeBlockRenderer($this->highlighter), 10)
24 |             ->addRenderer(Code::class, new InlineCodeBlockRenderer($this->highlighter), 10)
25 |         ;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Languages/Blade/Patterns/BladeComponentOpenTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Blade\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '<a attr="">', output: 'a')]
13 | #[PatternTest(input: '<x-hello attr="">', output: 'x-hello')]
14 | #[PatternTest(input: '<x-hello::world attr="">', output: 'x-hello::world')]
15 | #[PatternTest(input: '<x-hello::world.lorem attr="">', output: 'x-hello::world.lorem')]
16 | final readonly class BladeComponentOpenTagPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '<(?<match>[\w\-\:\.]+)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::KEYWORD;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PropertyHookSetPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenType;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | #[PatternTest(
14 |     '     public string $name {
15 |          set {',
16 |     'set'
17 | )]
18 | #[PatternTest('set;', 'set')]
19 | #[PatternTest('set =>', 'set')]
20 | #[PatternTest('set (string $value', 'set')]
21 | #[PatternTest('set(string $value', 'set')]
22 | final readonly class PropertyHookSetPattern implements Pattern
23 | {
24 |     use IsPattern;
25 | 
26 |     public function getPattern(): string
27 |     {
28 |         return '(?<match>set)\s*({|;|=>|\()';
29 |     }
30 | 
31 |     public function getTokenType(): TokenType
32 |     {
33 |         return TokenTypeEnum::KEYWORD;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Languages/Twig/TwigLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Twig;
 6 | 
 7 | use Tempest\Highlight\Languages\Html\HtmlLanguage;
 8 | use Tempest\Highlight\Languages\Twig\Injections\TwigEchoInjection;
 9 | use Tempest\Highlight\Languages\Twig\Injections\TwigTagInjection;
10 | use Tempest\Highlight\Languages\Twig\Patterns\TwigCommentPattern;
11 | 
12 | class TwigLanguage extends HtmlLanguage
13 | {
14 |     public function getName(): string
15 |     {
16 |         return 'twig';
17 |     }
18 | 
19 |     public function getInjections(): array
20 |     {
21 |         return [
22 |             ...parent::getInjections(),
23 |             new TwigTagInjection(),
24 |             new TwigEchoInjection(),
25 |         ];
26 |     }
27 | 
28 |     public function getPatterns(): array
29 |     {
30 |         return [
31 |             ...parent::getPatterns(),
32 |             new TwigCommentPattern(),
33 |         ];
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Languages/Dockerfile/Patterns/ImageNamePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Dockerfile\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM php', output: 'php')]
13 | #[PatternTest(input: ' FROM php', output: 'php')]
14 | #[PatternTest(input: 'FROM php:8.1', output: 'php')]
15 | #[PatternTest(input: 'FROM php/cli:8.1', output: 'php/cli')]
16 | #[PatternTest(input: 'FROM php:8.1 AS stage-one', output: 'php')]
17 | 
18 | final readonly class ImageNamePattern implements Pattern
19 | {
20 |     use IsPattern;
21 | 
22 |     public function getPattern(): string
23 |     {
24 |         return "/^[\s]*FROM[\s](?<match>[\w\/]+)/m";
25 |     }
26 | 
27 |     public function getTokenType(): TokenTypeEnum
28 |     {
29 |         return TokenTypeEnum::VALUE;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Languages/Dockerfile/Patterns/ImageTagPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Dockerfile\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'FROM php', output: null)]
13 | #[PatternTest(input: 'FROM php', output: null)]
14 | #[PatternTest(input: 'FROM php:8.1', output: '8.1')]
15 | #[PatternTest(input: 'FROM php/cli:8.1', output: '8.1')]
16 | #[PatternTest(input: 'FROM php:8.1 AS stage-one', output: '8.1')]
17 | 
18 | final readonly class ImageTagPattern implements Pattern
19 | {
20 |     use IsPattern;
21 | 
22 |     public function getPattern(): string
23 |     {
24 |         return "/^[\s]*FROM[\s][\w\/]+:(?<match>\S+)[\s]?/m";
25 |     }
26 | 
27 |     public function getTokenType(): TokenTypeEnum
28 |     {
29 |         return TokenTypeEnum::VALUE;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/SingleQuoteValuePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: "return 'hello';",
14 |     output: "'hello'",
15 | )]
16 | #[PatternTest(
17 |     input: "echo 'Yo\\';",
18 |     output: "'Yo\\'",
19 | )]
20 | #[PatternTest(
21 |     input: "echo 'Very \'long\'\\\'annoying\' string';",
22 |     output: "'Very \'long\'\\\'annoying\' string'",
23 | )]
24 | final readonly class SingleQuoteValuePattern implements Pattern
25 | {
26 |     use IsPattern;
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         return "(?<match>'(\\\'|.)*?')";
31 |     }
32 | 
33 |     public function getTokenType(): TokenTypeEnum
34 |     {
35 |         return TokenTypeEnum::VALUE;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Languages/Xml/Patterns/XmlCommentPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Xml\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'test
14 |             <!-- 
15 |             foo
16 |             -->
17 |             test',
18 |     output: '<!-- 
19 |             foo
20 |             -->'
21 | )]
22 | #[PatternTest(input: '<!-- foo --><div class="wrapper"><!-- foo2 -->', output: ['<!-- foo -->','<!-- foo2 -->'])]
23 | final readonly class XmlCommentPattern implements Pattern
24 | {
25 |     use IsPattern;
26 | 
27 |     public function getPattern(): string
28 |     {
29 |         return '/(?<match>\<!--(.|\n)*-->)/mU';
30 |     }
31 | 
32 |     public function getTokenType(): TokenTypeEnum
33 |     {
34 |         return TokenTypeEnum::COMMENT;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpDocCommentVarTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '@var array|string $concrete', output: 'array|string')]
13 | #[PatternTest(input: '@var \\Foo $concrete', output: '\\Foo')]
14 | #[PatternTest(input: '@var \DateTimeImmutable|null', output: '\DateTimeImmutable|null')]
15 | #[PatternTest(input: '/** @var Foo[] */', output: 'Foo[] ')]
16 | final readonly class PhpDocCommentVarTypePattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function getPattern(): string
21 |     {
22 |         return '\@var(\s)+(?<match>.*?)( \$|\*|$)';
23 |     }
24 | 
25 |     public function getTokenType(): TokenTypeEnum
26 |     {
27 |         return TokenTypeEnum::TYPE;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/KeywordPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\KeywordPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class KeywordPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new KeywordPattern('match'),
19 |             content: 'match ()',
20 |             expected: 'match',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new KeywordPattern('return'),
25 |             content: 'return ()',
26 |             expected: 'return',
27 |         );
28 | 
29 |         $this->assertMatches(
30 |             pattern: new KeywordPattern('class'),
31 |             content: 'class ()',
32 |             expected: 'class',
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Languages/Diff/DiffLanguageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Diff;
 6 | 
 7 | use PHPUnit\Framework\Attributes\DataProvider;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | 
11 | class DiffLanguageTest extends TestCase
12 | {
13 |     #[DataProvider('data')]
14 |     public function test_highlight(string $content, string $expected): void
15 |     {
16 |         $highlighter = new Highlighter();
17 | 
18 |         $this->assertSame(
19 |             $expected,
20 |             $highlighter->parse($content, 'diff'),
21 |         );
22 |     }
23 | 
24 |     public static function data(): array
25 |     {
26 |         return [
27 |             [<<<'TXT'
28 | + $this->newCode();
29 | - $this->oldCode();
30 | TXT,
31 |                 <<<'TXT'
32 | <span class="hl-addition">+  $this-&gt;newCode();</span>
33 | <span class="hl-deletion">-  $this-&gt;oldCode();</span>
34 | TXT
35 |             ],
36 |         ];
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/AttributeTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: '#[Foo(prop: hi)]', output: 'Foo')]
13 | #[PatternTest(input: '#[\Foo(prop: hi)]', output: '\Foo')]
14 | #[PatternTest(
15 |     input: '#[Foo(
16 |         uri: "/books/create",
17 |         "/books/create",
18 |     ),
19 |     Bar(uri: "/books/create"),
20 |     Baz,
21 | ]',
22 |     output: ['Foo', 'Bar', 'Baz']
23 | )]
24 | final readonly class AttributeTypePattern implements Pattern
25 | {
26 |     use IsPattern;
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         return '/(^[\s]*|\#\[)(?<match>[\\\\]*[A-Z][\w\\\\]+)/m';
31 |     }
32 | 
33 |     public function getTokenType(): TokenTypeEnum
34 |     {
35 |         return TokenTypeEnum::TYPE;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/PropertyAccessPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\PropertyAccessPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class PropertyAccessPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new PropertyAccessPattern(),
19 |             content: '$this->foo',
20 |             expected: 'foo',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new PropertyAccessPattern(),
25 |             content: '$this->foo()',
26 |             expected: 'foo',
27 |         );
28 | 
29 |         $this->assertMatches(
30 |             pattern: new PropertyAccessPattern(),
31 |             content: '$obj->foo',
32 |             expected: 'foo',
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Injections/PhpAttributePlainInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\IsInjection;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | final readonly class PhpAttributePlainInjection implements Injection
14 | {
15 |     use IsInjection;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\#\[[\w]+\])';
20 |     }
21 | 
22 |     public function parseContent(string $content, Highlighter $highlighter): string
23 |     {
24 |         $theme = $highlighter->getTheme();
25 | 
26 |         $parsed = '#[' . $highlighter->parse(str_replace(['#[', ']'], '', $content), 'php') . ']';
27 | 
28 |         return Escape::tokens($theme->before(TokenTypeEnum::ATTRIBUTE))
29 |             . $parsed
30 |             . Escape::tokens($theme->after(TokenTypeEnum::ATTRIBUTE));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/KeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class KeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     private bool $caseInsensitive = false;
16 | 
17 |     public function __construct(private string $keyword)
18 |     {
19 |     }
20 | 
21 |     public function caseInsensitive(): self
22 |     {
23 |         $this->caseInsensitive = true;
24 | 
25 |         return $this;
26 |     }
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         $pattern = "/\b(?<!\\$)(?<!\-\>)(?<match>{$this->keyword})(\$|\,|\)|\;|\:|\s|\()/";
31 | 
32 |         if ($this->caseInsensitive) {
33 |             $pattern .= 'i';
34 |         }
35 | 
36 |         return $pattern;
37 |     }
38 | 
39 |     public function getTokenType(): TokenTypeEnum
40 |     {
41 |         return TokenTypeEnum::KEYWORD;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Languages/JavaScript/Patterns/JsKeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\JavaScript\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final class JsKeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     private bool $caseInsensitive = false;
16 | 
17 |     public function __construct(private string $keyword)
18 |     {
19 |     }
20 | 
21 |     public function caseInsensitive(): self
22 |     {
23 |         $this->caseInsensitive = true;
24 | 
25 |         return $this;
26 |     }
27 | 
28 |     public function getPattern(): string
29 |     {
30 |         $pattern = "/\b(?<!\.)(?<match>{$this->keyword})(\,|\.|\)|\;|\:|\s|\()/";
31 | 
32 |         if ($this->caseInsensitive) {
33 |             $pattern .= 'i';
34 |         }
35 | 
36 |         return $pattern;
37 |     }
38 | 
39 |     public function getTokenType(): TokenTypeEnum
40 |     {
41 |         return TokenTypeEnum::KEYWORD;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Languages/Xml/XmlLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Xml;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | use Tempest\Highlight\Languages\Xml\Patterns\XmlAttributePattern;
 9 | use Tempest\Highlight\Languages\Xml\Patterns\XmlCloseTagPattern;
10 | use Tempest\Highlight\Languages\Xml\Patterns\XmlCommentPattern;
11 | use Tempest\Highlight\Languages\Xml\Patterns\XmlOpenTagPattern;
12 | 
13 | class XmlLanguage extends BaseLanguage
14 | {
15 |     public function getName(): string
16 |     {
17 |         return 'xml';
18 |     }
19 | 
20 |     public function getInjections(): array
21 |     {
22 |         return [
23 |             ...parent::getInjections(),
24 |         ];
25 |     }
26 | 
27 |     public function getPatterns(): array
28 |     {
29 |         return [
30 |             ...parent::getPatterns(),
31 |             new XmlOpenTagPattern(),
32 |             new XmlCloseTagPattern(),
33 |             new XmlAttributePattern(),
34 |             new XmlCommentPattern(),
35 |         ];
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENCE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | 
3 | Copyright (c) 2024 Brent Roose brendt@stitcher.io
4 | 
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6 | 
7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
8 | 
9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/src/Languages/Php/Injections/PhpAttributeInstanceInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Injections;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\IsInjection;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | final readonly class PhpAttributeInstanceInjection implements Injection
14 | {
15 |     use IsInjection;
16 | 
17 |     public function getPattern(): string
18 |     {
19 |         return '(?<match>\#\[[\w]+\((.|\n)*?\)\])';
20 |     }
21 | 
22 |     public function parseContent(string $content, Highlighter $highlighter): string
23 |     {
24 |         $theme = $highlighter->getTheme();
25 | 
26 |         $parsed = '#[' . $highlighter->parse(str_replace(['#[', ')]'], '', $content), 'php') . ')]';
27 | 
28 |         return Escape::injection(
29 |             Escape::tokens($theme->before(TokenTypeEnum::ATTRIBUTE))
30 |             . $parsed
31 |             . Escape::tokens($theme->after(TokenTypeEnum::ATTRIBUTE))
32 |         );
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Languages/Python/Patterns/PyKeywordPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Python\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\Tokens\TokenTypeEnum;
10 | 
11 | final readonly class PyKeywordPattern implements Pattern
12 | {
13 |     use IsPattern;
14 | 
15 |     public function __construct(private array $keywords = [
16 |         'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue',
17 |         'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
18 |         'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass',
19 |         'raise', 'return', 'try', 'while', 'with', 'yield',
20 |     ])
21 |     {
22 |     }
23 | 
24 |     public function getPattern(): string
25 |     {
26 |         $keywords = implode('|', $this->keywords);
27 | 
28 |         return "\b(?<match>(?:_(?=\s*:){$keywords}))\b";
29 |     }
30 | 
31 |     public function getTokenType(): TokenTypeEnum
32 |     {
33 |         return TokenTypeEnum::KEYWORD;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Injections/PhpShortEchoInjectionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Injections;
 6 | 
 7 | use PHPUnit\Framework\Attributes\Test;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Languages\Html\Injections\PhpShortEchoInHtmlInjection;
10 | use Tempest\Highlight\Tests\TestsInjections;
11 | 
12 | class PhpShortEchoInjectionTest extends TestCase
13 | {
14 |     use TestsInjections;
15 | 
16 |     #[Test]
17 |     public function test_injection(): void
18 |     {
19 |         $content = '
20 | Hello, <?= $this->name ?>
21 | Hello, <?= $this->other ?>
22 |         ';
23 | 
24 |         $expected = '
25 | Hello, &lt;?= <span class="hl-variable">$this</span>-&gt;<span class="hl-property">name</span> ?&gt;
26 | Hello, &lt;?= <span class="hl-variable">$this</span>-&gt;<span class="hl-property">other</span> ?&gt;
27 |         ';
28 | 
29 |         $this->assertMatches(
30 |             injection: new PhpShortEchoInHtmlInjection(),
31 |             content: $content,
32 |             expectedContent: $expected,
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Languages/Json/JsonLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Json;
 6 | 
 7 | use Tempest\Highlight\Languages\Base\BaseLanguage;
 8 | use Tempest\Highlight\Languages\Json\Patterns\JsonAccoladesPattern;
 9 | use Tempest\Highlight\Languages\Json\Patterns\JsonArrayBracketsPattern;
10 | use Tempest\Highlight\Languages\Json\Patterns\JsonDoubleQuoteValuePattern;
11 | use Tempest\Highlight\Languages\Json\Patterns\JsonPropertyPattern;
12 | 
13 | class JsonLanguage extends BaseLanguage
14 | {
15 |     public function getName(): string
16 |     {
17 |         return 'json';
18 |     }
19 | 
20 |     public function getInjections(): array
21 |     {
22 |         return [
23 |             ...parent::getInjections(),
24 |         ];
25 |     }
26 | 
27 |     public function getPatterns(): array
28 |     {
29 |         return [
30 |             ...parent::getPatterns(),
31 |             new JsonPropertyPattern(),
32 |             new JsonAccoladesPattern(),
33 |             new JsonArrayBracketsPattern(),
34 |             new JsonDoubleQuoteValuePattern(),
35 |         ];
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Languages/Php/Patterns/NamedArgumentPatternTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Php\Patterns;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | use Tempest\Highlight\Languages\Php\Patterns\NamedArgumentPattern;
 9 | use Tempest\Highlight\Tests\TestsPatterns;
10 | 
11 | class NamedArgumentPatternTest extends TestCase
12 | {
13 |     use TestsPatterns;
14 | 
15 |     public function test_pattern()
16 |     {
17 |         $this->assertMatches(
18 |             pattern: new NamedArgumentPattern(),
19 |             content: '#[Foo(prop: hi)]',
20 |             expected: 'prop',
21 |         );
22 | 
23 |         $this->assertMatches(
24 |             pattern: new NamedArgumentPattern(),
25 |             content: 'foo(bar: $a, baz: $b)',
26 |             expected: ['bar', 'baz'],
27 |         );
28 | 
29 |         $this->assertMatches(
30 |             pattern: new NamedArgumentPattern(),
31 |             content: 'foo(
32 |                 bar: $a, 
33 |                 baz: $b
34 |             )',
35 |             expected: ['bar', 'baz'],
36 |         );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/TestsInjections.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests;
 6 | 
 7 | use Tempest\Highlight\Escape;
 8 | use Tempest\Highlight\Highlighter;
 9 | use Tempest\Highlight\Injection;
10 | use Tempest\Highlight\Language;
11 | 
12 | trait TestsInjections
13 | {
14 |     public function assertMatches(
15 |         Injection $injection,
16 |         string $content,
17 |         string|array|null $expectedContent,
18 |         Language|null $currentLanguage = null,
19 |     ) {
20 |         $highlighter = (new Highlighter())->nested();
21 | 
22 |         if ($currentLanguage) {
23 |             $highlighter->setCurrentLanguage($currentLanguage);
24 |         }
25 | 
26 |         $parsedInjection = $injection->parse($content, $highlighter);
27 | 
28 |         if (is_string($parsedInjection)) {
29 |             $content = $parsedInjection;
30 |         } else {
31 |             $content = $parsedInjection->content;
32 |         }
33 | 
34 |         $output = Escape::html($content);
35 | 
36 |         $this->assertSame(
37 |             $expectedContent,
38 |             $output,
39 |         );
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/Languages/Xml/XmlLanguageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Xml;
 6 | 
 7 | use PHPUnit\Framework\Attributes\DataProvider;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | 
11 | class XmlLanguageTest extends TestCase
12 | {
13 |     #[DataProvider('data')]
14 |     public function test_highlight(string $content, string $expected): void
15 |     {
16 |         $highlighter = new Highlighter();
17 | 
18 |         $this->assertSame(
19 |             $expected,
20 |             $highlighter->parse($content, 'xml'),
21 |         );
22 |     }
23 | 
24 |     public static function data(): array
25 |     {
26 |         return [
27 |             [<<<TXT
28 | <tag attr="">
29 |     <br/>
30 |     
31 |     <!-- comment -->
32 | </tag>
33 | TXT,
34 |                 <<<TXT
35 | &lt;<span class="hl-keyword">tag</span> <span class="hl-property">attr</span>=&quot;&quot;&gt;
36 |     &lt;<span class="hl-keyword">br</span>/&gt;
37 |     
38 |     <span class="hl-comment">&lt;!-- comment --&gt;</span>
39 | &lt;/<span class="hl-keyword">tag</span>&gt;
40 | TXT],
41 |         ];
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/TypeForVariablePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'Bar $bar, Baz $baz', output: ['Bar', 'Baz'])]
13 | #[PatternTest(input: 'Foo|Bar $bar, Baz $baz', output: ['Foo|Bar', 'Baz'])]
14 | #[PatternTest(input: '?Bar $bar, Baz $baz', output: ['?Bar', 'Baz'])]
15 | #[PatternTest(input: 'Foo|Bar|null $bar', output: 'Foo|Bar|null')]
16 | #[PatternTest(input: '(Foo&Bar)|null $bar', output: '(Foo&Bar)|null')]
17 | #[PatternTest(input: 'string|\Stringable $bar', output: 'string|\Stringable')]
18 | #[PatternTest(input: 'Foo ...$params', output: 'Foo')]
19 | final readonly class TypeForVariablePattern implements Pattern
20 | {
21 |     use IsPattern;
22 | 
23 |     public function getPattern(): string
24 |     {
25 |         return '(?<match>[\w\&\(\)\|\\\\\?]+)\s+(\.*)\\$';
26 |     }
27 | 
28 |     public function getTokenType(): TokenTypeEnum
29 |     {
30 |         return TokenTypeEnum::TYPE;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/CommonMark/InlineCodeBlockRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\CommonMark;
 6 | 
 7 | use InvalidArgumentException;
 8 | use League\CommonMark\Extension\CommonMark\Node\Inline\Code;
 9 | use League\CommonMark\Node\Node;
10 | use League\CommonMark\Renderer\ChildNodeRendererInterface;
11 | use League\CommonMark\Renderer\NodeRendererInterface;
12 | use Tempest\Highlight\Highlighter;
13 | 
14 | final class InlineCodeBlockRenderer implements NodeRendererInterface
15 | {
16 |     public function __construct(
17 |         private Highlighter $highlighter = new Highlighter(),
18 |     ) {
19 |     }
20 | 
21 |     public function render(Node $node, ChildNodeRendererInterface $childRenderer)
22 |     {
23 |         if (! $node instanceof Code) {
24 |             throw new InvalidArgumentException('Block must be instance of ' . Code::class);
25 |         }
26 | 
27 |         preg_match('/^\{(?<match>[\w]+)}(?<code>.*)/', $node->getLiteral(), $match);
28 | 
29 |         $language = $match['match'] ?? 'txt';
30 |         $code = $match['code'] ?? $node->getLiteral();
31 | 
32 |         return '<code>' . $this->highlighter->parse($code, $language) . '</code>';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/CommonMark/HighlightExtensionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\CommonMark;
 6 | 
 7 | use League\CommonMark\Environment\Environment;
 8 | use League\CommonMark\Extension\CommonMark\CommonMarkCoreExtension;
 9 | use League\CommonMark\Extension\FrontMatter\FrontMatterExtension;
10 | use League\CommonMark\MarkdownConverter;
11 | use PHPUnit\Framework\TestCase;
12 | use Tempest\Highlight\CommonMark\HighlightExtension;
13 | 
14 | class HighlightExtensionTest extends TestCase
15 | {
16 |     public function test_highlight_extension(): void
17 |     {
18 |         $environment = new Environment();
19 | 
20 |         $environment
21 |             ->addExtension(new CommonMarkCoreExtension())
22 |             ->addExtension(new HighlightExtension())
23 |             ->addExtension(new FrontMatterExtension());
24 | 
25 |         $markdown = new MarkdownConverter($environment);
26 | 
27 |         $parsed = $markdown->convert("```php
28 |         class Foo {}
29 |         ```");
30 | 
31 |         $this->assertStringContainsString('hl-keyword', $parsed->getContent());
32 |         $this->assertStringContainsString('data-lang="php"', $parsed->getContent());
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Tokens/TokenTypeEnum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tokens;
 6 | 
 7 | enum TokenTypeEnum: string implements TokenType
 8 | {
 9 |     case KEYWORD = 'keyword';
10 |     case OPERATOR = 'operator';
11 |     case TYPE = 'type';
12 |     case VALUE = 'value';
13 |     case VARIABLE = 'variable';
14 |     case PROPERTY = 'property';
15 |     case ATTRIBUTE = 'attribute';
16 |     case GENERIC = 'generic';
17 |     case NUMBER = 'number';
18 |     case LITERAL = 'literal';
19 |     case COMMENT = 'comment';
20 |     case INJECTION = 'injection';
21 |     case HIDDEN = 'hidden';
22 | 
23 |     public function getValue(): string
24 |     {
25 |         return $this->value;
26 |     }
27 | 
28 |     public function canContain(TokenType $other): bool
29 |     {
30 |         if ($this === $other) {
31 |             return false;
32 |         }
33 | 
34 |         return match ($this) {
35 |             self::TYPE => ! in_array($other->getValue(), [self::KEYWORD->getValue(), self::PROPERTY->getValue()]),
36 |             self::GENERIC => ! in_array($other->getValue(), [self::TYPE->getValue()]),
37 |             self::ATTRIBUTE => true,
38 |             default => false,
39 |         };
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ReturnTypePattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'function foo(): Bar;', output: 'Bar')]
13 | #[PatternTest(input: 'function foo(): Bar{}', output: 'Bar')]
14 | #[PatternTest(input: 'function foo(): Bar {}', output: 'Bar')]
15 | #[PatternTest(input: 'function foo(): Bar 
16 | {}', output: 'Bar')]
17 | #[PatternTest(input: 'function foo(): ?Bar;', output: '?Bar')]
18 | #[PatternTest(input: 'function foo(): Foo|Bar;', output: 'Foo|Bar')]
19 | #[PatternTest(input: 'function foo(): Foo&Bar;', output: 'Foo&Bar')]
20 | #[PatternTest(input: 'function foo(): (Foo&Bar)|null;', output: '(Foo&Bar)|null')]
21 | final readonly class ReturnTypePattern implements Pattern
22 | {
23 |     use IsPattern;
24 | 
25 |     public function getPattern(): string
26 |     {
27 |         return '\)\s*\:\s*(?<match>[\w\(\)\&\|\?]+)[\s{;\n]';
28 |     }
29 | 
30 |     public function getTokenType(): TokenTypeEnum
31 |     {
32 |         return TokenTypeEnum::TYPE;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Languages/Json/JsonLanguageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Tests\Languages\Json;
 6 | 
 7 | use PHPUnit\Framework\Attributes\DataProvider;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Tempest\Highlight\Highlighter;
10 | 
11 | class JsonLanguageTest extends TestCase
12 | {
13 |     #[DataProvider('data')]
14 |     public function test_highlight(string $content, string $expected): void
15 |     {
16 |         $highlighter = new Highlighter();
17 | 
18 |         $this->assertSame(
19 |             $expected,
20 |             $highlighter->parse($content, 'json'),
21 |         );
22 |     }
23 | 
24 |     public static function data(): array
25 |     {
26 |         return [
27 |             [
28 |                 '{
29 |     "key": "value",
30 |     "array": ["bar"]
31 | }',
32 |                 '<span class="hl-property">{</span>
33 |     <span class="hl-keyword">&quot;key&quot;</span>: <span class="hl-value">&quot;value&quot;</span>,
34 |     <span class="hl-keyword">&quot;array&quot;</span>: <span class="hl-property">[</span><span class="hl-value">&quot;bar&quot;</span><span class="hl-property">]</span>
35 | <span class="hl-property">}</span>',
36 |             ],
37 |         ];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/IsInjection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight;
 6 | 
 7 | trait IsInjection
 8 | {
 9 |     abstract public function getPattern(): string;
10 | 
11 |     abstract public function parseContent(string $content, Highlighter $highlighter): string;
12 | 
13 |     public function parse(string $content, Highlighter $highlighter): ParsedInjection
14 |     {
15 |         $pattern = $this->getPattern();
16 | 
17 |         if (! str_starts_with($pattern, '/')) {
18 |             $pattern = "/{$pattern}/";
19 |         }
20 | 
21 |         $result = preg_replace_callback(
22 |             pattern: $pattern,
23 |             callback: function ($matches) use ($highlighter) {
24 |                 $content = $matches['match'] ?? '';
25 | 
26 |                 if (! $content) {
27 |                     return $matches[0];
28 |                 }
29 | 
30 |                 return str_replace(
31 |                     search: $content,
32 |                     replace: $this->parseContent($content, $highlighter),
33 |                     subject: $matches[0],
34 |                 );
35 |             },
36 |             subject: $content,
37 |         );
38 | 
39 |         return new ParsedInjection($result ?? $content);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Languages/Html/HtmlLanguage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Html;
 6 | 
 7 | use Tempest\Highlight\Languages\Html\Injections\CssAttributeInHtmlInjection;
 8 | use Tempest\Highlight\Languages\Html\Injections\CssInHtmlInjection;
 9 | use Tempest\Highlight\Languages\Html\Injections\JavaScriptInHtmlInjection;
10 | use Tempest\Highlight\Languages\Html\Injections\PhpInHtmlInjection;
11 | use Tempest\Highlight\Languages\Html\Injections\PhpShortEchoInHtmlInjection;
12 | use Tempest\Highlight\Languages\Xml\XmlLanguage;
13 | 
14 | class HtmlLanguage extends XmlLanguage
15 | {
16 |     public function getName(): string
17 |     {
18 |         return 'html';
19 |     }
20 | 
21 |     public function getInjections(): array
22 |     {
23 |         return [
24 |             ...parent::getInjections(),
25 |             new PhpInHtmlInjection(),
26 |             new PhpShortEchoInHtmlInjection(),
27 |             new CssInHtmlInjection(),
28 |             new CssAttributeInHtmlInjection(),
29 |             new JavaScriptInHtmlInjection(),
30 |         ];
31 |     }
32 | 
33 |     public function getPatterns(): array
34 |     {
35 |         return [
36 |             ...parent::getPatterns(),
37 |         ];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Themes/Css/highlight-dark-lite.css:
--------------------------------------------------------------------------------
 1 | pre, code {
 2 |     color: #fafafa;
 3 |     background-color: #0c0c0c;
 4 | }
 5 | 
 6 | .hl-keyword {
 7 |     color: #bd7a0b;
 8 | }
 9 | 
10 | .hl-property {
11 |     color: #cb57ac;
12 | }
13 | 
14 | .hl-attribute {
15 |     font-style: italic;
16 | }
17 | 
18 | .hl-type {
19 |     color: #15bccb;
20 | }
21 | 
22 | .hl-generic {
23 |     color: #62c509;
24 | }
25 | 
26 | .hl-value {
27 |     color: #fafafa;
28 | }
29 | 
30 | .hl-variable {
31 |     color: #fafafa;
32 | }
33 | 
34 | .hl-comment span,
35 | .hl-comment {
36 |     color: #888;
37 | }
38 | 
39 | .hl-blur {
40 |     filter: blur(2px);
41 | }
42 | 
43 | .hl-strong {
44 |     font-weight: bold;
45 | }
46 | 
47 | .hl-em {
48 |     font-style: italic;
49 | }
50 | 
51 | .hl-addition {
52 |     min-width: 100%;
53 |     background-color: #00FF0033;
54 | }
55 | 
56 | .hl-deletion {
57 |     min-width: 100%;
58 |     background-color: #FF000022;
59 | }
60 | 
61 | .hl-gutter {
62 |     display: inline-block;
63 |     margin-right: 1ch;
64 |     font-size: 0.9em;
65 |     color: #555;
66 |     padding: 0 1ch;
67 | }
68 | 
69 | .hl-gutter-addition {
70 |     background-color: #34A853;
71 |     color: #fff;
72 | }
73 | 
74 | .hl-gutter-deletion {
75 |     background-color: #EA4334;
76 |     color: #fff;
77 | }


--------------------------------------------------------------------------------
/tests/targets/gdscript.md:
--------------------------------------------------------------------------------
 1 | ```gdscript
 2 | extends CharacterBody2D
 3 | class_name GamePlayer
 4 | 
 5 | @export var navigation : NavigationRegion2D
 6 | @export var speed : int = 75
 7 | 
 8 | @onready var agent := %Agent as NavigationAgent2D
 9 | 
10 | func _ready() -> void:
11 | 	agent.max_speed = speed
12 | 
13 | 	agent.connect("velocity_computed", func(new_velocity: Vector2):
14 | 		# use velocity_computed so that obstacles are avoided
15 | 		if not agent.is_navigation_finished():
16 | 			velocity = new_velocity
17 | 			move_and_slide()
18 | 	)
19 | 
20 | func _physics_process(_delta) -> void:
21 | 	var next_location = agent.get_next_path_position()
22 | 	
23 | 	if global_position.distance_to(next_location) > 1:
24 | 		update_navigation()
25 | 		
26 | 		if not agent.is_navigation_finished():
27 | 			var next_move_position = agent.get_next_path_position() - global_position
28 | 			agent.velocity =  next_move_position * speed
29 | 
30 | 	if Input.is_action_pressed("ui_move"):
31 | 		agent.target_position = get_global_mouse_position()
32 | 
33 | func update_navigation() -> void:
34 | 	# move the navigation region so that the player is always in the center
35 | 	navigation.global_position = global_position - (get_viewport().get_visible_rect().size / 2)
36 | 	navigation.bake_navigation_polygon()
37 | ```
38 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/ClassPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(input: 'public Foo $foo', output: '$foo')]
13 | #[PatternTest(input: 'private Foo $foo', output: '$foo')]
14 | #[PatternTest(input: 'protected Foo $foo', output: '$foo')]
15 | #[PatternTest(input: 'public Foo|Bar $foo', output: '$foo')]
16 | #[PatternTest(input: 'public Foo&Bar $foo', output: '$foo')]
17 | #[PatternTest(input: 'public (Foo&Bar)|null $foo', output: '$foo')]
18 | #[PatternTest(input: 'private(set) Foo $foo;', output: '$foo')]
19 | #[PatternTest(input: 'public(set) Foo $foo;', output: '$foo')]
20 | #[PatternTest(input: 'protected(set) Foo $foo;', output: '$foo')]
21 | final readonly class ClassPropertyPattern implements Pattern
22 | {
23 |     use IsPattern;
24 | 
25 |     public function getPattern(): string
26 |     {
27 |         return '(public|private|protected)(\(set\))?(\s(.+?)) (?<match>\\$[\w]+)';
28 |     }
29 | 
30 |     public function getTokenType(): TokenTypeEnum
31 |     {
32 |         return TokenTypeEnum::PROPERTY;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Languages/Css/Patterns/CssSelectorPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Css\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenTypeEnum;
11 | 
12 | #[PatternTest(
13 |     input: 'code, .asd, #id,
14 | .hl-blur, @font-face,
15 | kbd, samp,
16 | pre {
17 |     font-family: ui-monospace, monospace;
18 | }',
19 |     output: 'code, .asd, #id,
20 | .hl-blur, @font-face,
21 | kbd, samp,
22 | pre ',
23 | )]
24 | #[PatternTest(input: "[data-x='asd'] .light {", output: "[data-x='asd'] .light ")]
25 | #[PatternTest(input: "foo + bar {", output: "foo + bar ")]
26 | #[PatternTest(input: "foo:hover {", output: "foo:hover ")]
27 | #[PatternTest(input: "body *:not(html):not(style):not(br):not(tr):not(code) {", output: "body *:not(html):not(style):not(br):not(tr):not(code) ")]
28 | final readonly class CssSelectorPattern implements Pattern
29 | {
30 |     use IsPattern;
31 | 
32 |     public function getPattern(): string
33 |     {
34 |         return '(?<match>[\[\]\'\"\=\@\-\#\.\w\s,\n\+\:\(\)\*]+)\{';
35 |     }
36 | 
37 |     public function getTokenType(): TokenTypeEnum
38 |     {
39 |         return TokenTypeEnum::KEYWORD;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Languages/Php/Patterns/PhpAsymmetricPropertyPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Tempest\Highlight\Languages\Php\Patterns;
 6 | 
 7 | use Tempest\Highlight\IsPattern;
 8 | use Tempest\Highlight\Pattern;
 9 | use Tempest\Highlight\PatternTest;
10 | use Tempest\Highlight\Tokens\TokenType;
11 | use Tempest\Highlight\Tokens\TokenTypeEnum;
12 | 
13 | #[PatternTest(input: 'public public(set) Foo $foo', output: 'set')]
14 | #[PatternTest(input: 'public private(set) Foo $foo', output: 'set')]
15 | #[PatternTest(input: 'public protected(set) Foo $foo', output: 'set')]
16 | final readonly class PhpAsymmetricPropertyPattern implements Pattern
17 | {
18 |     use IsPattern;
19 | 
20 |     public function match(string $content): array
21 |     {
22 |         $pattern = $this->getPattern();
23 | 
24 |         if (! str_starts_with($pattern, '/')) {
25 |             $pattern = "/$pattern/";
26 |         }
27 | 
28 |         preg_match_all($pattern, $content, $matches, PREG_OFFSET_CAPTURE);
29 | 
30 |         return $matches;
31 |     }
32 | 
33 |     public function getPattern(): string
34 |     {
35 |         return '/(public|private|protected)\((?<match>set)\)/';
36 |     }
37 | 
38 |     public function getTokenType(): TokenType
39 |     {
40 |         return TokenTypeEnum::KEYWORD;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Themes/Css/highlight-light-lite.css:
--------------------------------------------------------------------------------
 1 | pre, code {
 2 |     color: #000;
 3 |     background-color: #f3f3f3;
 4 | }
 5 | 
 6 | .hl-keyword {
 7 |     color: #4285F4;
 8 | }
 9 | 
10 | .hl-property {
11 |     color: #34A853;
12 | }
13 | 
14 | .hl-attribute {
15 |     font-style: italic;
16 | }
17 | 
18 | .hl-type {
19 |     color: #EA4334;
20 | }
21 | 
22 | .hl-generic {
23 |     color: #9d3af6;
24 | }
25 | 
26 | .hl-number,
27 | .hl-literal,
28 | .hl-value {
29 |     color: #000;
30 | }
31 | 
32 | .hl-variable {
33 |     color: #000;
34 | }
35 | 
36 | .hl-comment {
37 |     color: #888888;
38 | }
39 | 
40 | .hl-blur {
41 |     filter: blur(2px);
42 | }
43 | 
44 | .hl-strong {
45 |     font-weight: bold;
46 | }
47 | 
48 | .hl-em {
49 |     font-style: italic;
50 | }
51 | 
52 | .hl-addition {
53 |     min-width: 100%;
54 |     background-color: #00FF0022;
55 | }
56 | 
57 | .hl-deletion {
58 |     min-width: 100%;
59 |     background-color: #FF000011;
60 | }
61 | 
62 | .hl-gutter {
63 |     display: inline-block;
64 |     font-size: 0.9em;
65 |     color: #555;
66 |     padding: 0 1ch;
67 |     margin-right: 1ch;
68 |     user-select: none;
69 | }
70 | 
71 | .hl-gutter-addition {
72 |     background-color: #34A853;
73 |     color: #fff;
74 | }
75 | 
76 | .hl-gutter-deletion {
77 |     background-color: #EA4334;
78 |     color: #fff;
79 | }


--------------------------------------------------------------------------------