├── .github
    ├── ISSUE_TEMPLATE.md
    ├── PULL_REQUEST_TEMPLATE.md
    ├── SECURITY.md
    └── workflows
    │   └── build.yml
├── Base
    ├── Container.php
    ├── Controller.php
    ├── Event.php
    ├── Middleware.php
    ├── Model.php
    ├── Module.php
    ├── PageController.php
    ├── ReadonlyContainer.php
    ├── ReadonlyModel.php
    ├── RollbackInterface.php
    ├── Scheduler.php
    └── Task.php
├── Constructor
    ├── Actions
    │   ├── ActionInterface.php
    │   ├── ClearCacheAction.php
    │   └── UpdateRouteCacheAction.php
    ├── Attributes
    │   ├── Accessible.php
    │   ├── Autowiring
    │   │   ├── AllowAutowire.php
    │   │   ├── Config.php
    │   │   ├── DI.php
    │   │   └── NoAutowire.php
    │   ├── AvailableAsParent.php
    │   ├── Dependency.php
    │   ├── Disabled.php
    │   ├── ForTestOnly.php
    │   ├── Hidden.php
    │   ├── NotFinal.php
    │   └── Task
    │   │   └── Purpose.php
    ├── Cache
    │   ├── CacheRoutes.php
    │   ├── ClassWithDataCreator.php
    │   ├── ClearRandomFileCache.php
    │   ├── OnceResult.php
    │   ├── RouteMark.php
    │   └── WebCron.php
    ├── Containers
    │   ├── BaseContainerFactory.php
    │   ├── ContainerTrait.php
    │   ├── CoreContainer.php
    │   ├── CoreContainerInterface.php
    │   └── TestContainerInterface.php
    ├── DI
    │   └── DependencyInjection.php
    ├── Data
    │   ├── DebugAnalytics.php
    │   ├── DynamicParams.php
    │   ├── Key.php
    │   ├── MainLogLevel.php
    │   ├── RoutesPreview.php
    │   ├── SystemSettings.php
    │   ├── UrlManager.php
    │   └── View.php
    ├── Exceptions
    │   ├── Cause
    │   │   ├── DomainException.php
    │   │   ├── DynamicStateException.php
    │   │   ├── InvalidArgumentException.php
    │   │   ├── ParseException.php
    │   │   └── UnexpectedValueException.php
    │   ├── CoreErrorException.php
    │   ├── CoreException.php
    │   ├── CoreProcessException.php
    │   ├── Database
    │   │   └── DatabaseException.php
    │   ├── Exit
    │   │   └── AsyncExitException.php
    │   ├── File
    │   │   ├── FileResourceAccessException.php
    │   │   ├── FileResourceModificationException.php
    │   │   └── FileSystemException.php
    │   ├── FrameworkException.php
    │   ├── Http
    │   │   ├── Http400BadRequestException.php
    │   │   ├── Http401UnauthorizedException.php
    │   │   ├── Http403ForbiddenException.php
    │   │   ├── Http404NotFoundException.php
    │   │   ├── Http406NotAcceptableException.php
    │   │   ├── Http409ConflictException.php
    │   │   ├── Http410GoneException.php
    │   │   ├── Http429TooManyRequestsException.php
    │   │   ├── Http500InternalServerErrorException.php
    │   │   └── Http503ServiceUnavailableException.php
    │   ├── HttpException.php
    │   ├── Log
    │   │   └── InvalidLogLevelException.php
    │   ├── Reflection
    │   │   └── ReflectionProcessException.php
    │   └── Route
    │   │   ├── AsyncRouteException.php
    │   │   └── RouteColoredException.php
    ├── Models
    │   └── ModelTrait.php
    ├── Protected
    │   └── Csrf.php
    ├── Script
    │   └── Hlogin.php
    └── Templates
    │   ├── PhpTemplate.php
    │   ├── Template.php
    │   ├── TemplateInterface.php
    │   └── TwigTemplate.php
├── Database
    ├── DbExcessLog.php
    ├── PdoManager.php
    ├── StandardDB.php
    └── SystemDB.php
├── Helpers
    ├── Abracadabra.php
    ├── ArrayHelper.php
    ├── ArrayWriting.php
    ├── AttributeHelper.php
    ├── ClassDataInFile.php
    ├── DefaultValueHelper.php
    ├── DirectoryCleaner.php
    ├── DirectoryHelper.php
    ├── DirectoryInspector.php
    ├── HostHelper.php
    ├── NameConverter.php
    ├── PhpCommentHelper.php
    ├── ProtectedFileSaver.php
    ├── RangeChecker.php
    ├── ReflectionConstant.php
    ├── ReflectionMethod.php
    ├── ResourceViewHelper.php
    ├── RouteHelper.php
    ├── StorageLibConfigurator.php
    ├── StrToList.php
    ├── StringHelper.php
    └── TaskHelper.php
├── HlebAsyncBootstrap.php
├── HlebBootstrap.php
├── HlebConsoleBootstrap.php
├── HlebQueueBootstrap.php
├── HttpMethods
    ├── External
    │   ├── RequestUri.php
    │   ├── Response.php
    │   ├── SpareRequest.php
    │   └── SystemRequest.php
    ├── Intelligence
    │   ├── AsyncConsolidator.php
    │   └── Cookies
    │   │   ├── AsyncCookies.php
    │   │   ├── CookieInterface.php
    │   │   ├── ParseCookies.php
    │   │   └── StandardCookies.php
    └── Specifier
    │   └── DataType.php
├── Init
    ├── AddressBar.php
    ├── Autoloader.php
    ├── Connectors
    │   ├── HlebConnector.php
    │   ├── PhphlebConnector.php
    │   └── Preload
    │   │   └── search-functions.php
    ├── CustomAutoloader.php
    ├── ErrorLog.php
    ├── Functions.php
    ├── Headers
    │   ├── ParsePsrHeaders.php
    │   └── ParseSwooleHeaders.php
    ├── Review
    │   ├── basic.php
    │   └── functions.php
    └── ShootOneselfInTheFoot
    │   ├── ArrForTest.php
    │   ├── BaseMockAddOn.php
    │   ├── CacheForTest.php
    │   ├── CommandForTest.php
    │   ├── ContainerForTest.php
    │   ├── ConverterForTest.php
    │   ├── CookiesForTest.php
    │   ├── CsrfForTest.php
    │   ├── DbForTest.php
    │   ├── DebugForTest.php
    │   ├── DiForTest.php
    │   ├── LogForTest.php
    │   ├── Mock.php
    │   ├── OnceForTest.php
    │   ├── PatchForTest.php
    │   ├── RedirectForTest.php
    │   ├── RequestForTest.php
    │   ├── ResponseForTest.php
    │   ├── RouterForTest.php
    │   ├── ScriptForTest.php
    │   ├── SessionForTest.php
    │   ├── SettingForTest.php
    │   ├── SystemForTest.php
    │   ├── TemplateForTest.php
    │   └── ViewForTest.php
├── LICENSE
├── Main
    ├── BaseErrorPage.php
    ├── Console
    │   ├── Colorizer.php
    │   ├── Commands
    │   │   ├── CliLogLevel.php
    │   │   ├── ConfigInfo.php
    │   │   ├── CustomTask.php
    │   │   ├── Deployer
    │   │   │   ├── DeploymentLibInterface.php
    │   │   │   ├── LibDeployerCreator.php
    │   │   │   ├── LibDeployerFinder.php
    │   │   │   └── LibraryDeployer.php
    │   │   ├── Features
    │   │   │   ├── AutoloaderSupport
    │   │   │   │   └── AutoloaderSupport.php
    │   │   │   ├── CodeCleanup
    │   │   │   │   └── ClearingComments.php
    │   │   │   ├── CommandDetails
    │   │   │   │   ├── AllCommands.php
    │   │   │   │   ├── CommandArgument.php
    │   │   │   │   └── CustomList.php
    │   │   │   ├── ExecutionSpeed
    │   │   │   │   └── ExecutionSpeed.php
    │   │   │   ├── FeatureInterface.php
    │   │   │   ├── FlatKegling
    │   │   │   │   ├── Calculations.php
    │   │   │   │   ├── ExpressionTrait.php
    │   │   │   │   ├── FlatKeglingGame.php
    │   │   │   │   ├── StartData.php
    │   │   │   │   └── WinStorage.php
    │   │   │   ├── OriginCommand
    │   │   │   │   └── OriginCommandReturn.php
    │   │   │   └── ReverseMode
    │   │   │   │   ├── ReverseHlCheckMode.php
    │   │   │   │   └── ReverseStrictMode.php
    │   │   ├── FindRouteTrait.php
    │   │   ├── Help
    │   │   │   └── HelpGenerator.php
    │   │   ├── LatestLogs.php
    │   │   ├── LockProject.php
    │   │   ├── RouteCacheUpdater.php
    │   │   ├── RouteClearCache.php
    │   │   ├── RouteInfo.php
    │   │   ├── RouteList.php
    │   │   ├── SearchRoute.php
    │   │   ├── ShortList.php
    │   │   ├── TemplateCreator.php
    │   │   └── TwigCacheUpdater.php
    │   ├── Console.php
    │   ├── ConsoleAdapter.php
    │   ├── ConsoleHandler.php
    │   ├── Extreme
    │   │   ├── ExtremeDataTransfer.php
    │   │   ├── ExtremeIdentifier.php
    │   │   ├── ExtremeRegister.php
    │   │   ├── ExtremeRequest.php
    │   │   └── ExtremeTerminal.php
    │   ├── IndexedArgConverter.php
    │   ├── ReplacingColorizer.php
    │   ├── Sections
    │   │   └── ModuleCreator.php
    │   ├── Specifiers
    │   │   ├── ArgType.php
    │   │   └── LightDataType.php
    │   ├── WebConsole.php
    │   └── WebConsoleOnPage.php
    ├── ErrorTemplates.php
    ├── Info
    │   └── PathInfoDoc.php
    ├── Insert
    │   ├── BaseAsyncSingleton.php
    │   ├── BaseSingleton.php
    │   ├── ContainerUniqueItem.php
    │   ├── ExternalSingleton.php
    │   └── OpenInstanceSingleton.php
    ├── Logger
    │   ├── BaseLogger.php
    │   ├── FileLogger.php
    │   ├── Log.php
    │   ├── LogCleaner.php
    │   ├── LogLevel.php
    │   ├── LoggerAdapter.php
    │   ├── LoggerInterface.php
    │   ├── LoggerWrapper.php
    │   ├── NullLogger.php
    │   └── StreamLogger.php
    ├── ProjectLoader.php
    ├── RouteExtractor.php
    ├── Routes
    │   ├── BaseRoute.php
    │   ├── Methods
    │   │   ├── BaseType.php
    │   │   └── Traits
    │   │   │   ├── Group
    │   │   │       ├── GroupAfterTrait.php
    │   │   │       ├── GroupBeforeTrait.php
    │   │   │       ├── GroupDomainTrait.php
    │   │   │       ├── GroupMiddlewareTrait.php
    │   │   │       ├── GroupNoDebugTrait.php
    │   │   │       ├── GroupPlainTrait.php
    │   │   │       ├── GroupPrefixTrait.php
    │   │   │       ├── GroupProtectTrait.php
    │   │   │       ├── GroupTrait.php
    │   │   │       ├── GroupWhereTrait.php
    │   │   │       └── StandardGroupTrait.php
    │   │   │   ├── InsertAfterTrait.php
    │   │   │   ├── InsertBeforeTrait.php
    │   │   │   ├── InsertControllerTrait.php
    │   │   │   ├── InsertDomainTrait.php
    │   │   │   ├── InsertMiddlewareTrait.php
    │   │   │   ├── InsertModuleTrait.php
    │   │   │   ├── InsertNameTrait.php
    │   │   │   ├── InsertNoDebugTrait.php
    │   │   │   ├── InsertPageTrait.php
    │   │   │   ├── InsertPlainTrait.php
    │   │   │   ├── InsertProtectTrait.php
    │   │   │   ├── InsertRedirectTrait.php
    │   │   │   ├── InsertWhereTrait.php
    │   │   │   └── StandardTrait.php
    │   ├── Prepare
    │   │   ├── Defender.php
    │   │   ├── FileChecker.php
    │   │   ├── Handler.php
    │   │   ├── Optimizer.php
    │   │   └── Verifier.php
    │   ├── Route.php
    │   ├── Search
    │   │   ├── FindRoute.php
    │   │   ├── RouteAnyFileManager.php
    │   │   ├── RouteAsyncFileManager.php
    │   │   ├── RouteFileManager.php
    │   │   └── SearchBlock.php
    │   ├── StandardRoute.php
    │   └── Update
    │   │   ├── CheckRouteForUpdates.php
    │   │   └── RouteData.php
    ├── System
    │   ├── LibraryServiceAddress.php
    │   └── LibraryServiceResources.php
    └── Workspace.php
├── Optional
    ├── Modules
    │   └── example
    │   │   ├── config
    │   │       └── main.php
    │   │   ├── controllers
    │   │       └── DefaultModuleController.php
    │   │   └── views
    │   │       └── example.php
    └── Templates
    │   ├── controller_class_template.php
    │   ├── middleware_class_template.php
    │   ├── model_class_template.php
    │   └── task_class_template.php
├── Reference
    ├── ArrInterface.php
    ├── ArrReference.php
    ├── CacheInterface.php
    ├── CacheReference.php
    ├── CommandInterface.php
    ├── CommandReference.php
    ├── ConverterInterface.php
    ├── ConverterReference.php
    ├── CookieInterface.php
    ├── CookieReference.php
    ├── CsrfInterface.php
    ├── CsrfReference.php
    ├── DbInterface.php
    ├── DbReference.php
    ├── DebugInterface.php
    ├── DebugReference.php
    ├── DiInterface.php
    ├── DiReference.php
    ├── DtoInterface.php
    ├── DtoReference.php
    ├── Interface
    │   ├── Arr.php
    │   ├── Cache.php
    │   ├── Command.php
    │   ├── Converter.php
    │   ├── Cookie.php
    │   ├── Csrf.php
    │   ├── DI.php
    │   ├── Db.php
    │   ├── Debug.php
    │   ├── Dto.php
    │   ├── Log.php
    │   ├── Path.php
    │   ├── Redirect.php
    │   ├── Request.php
    │   ├── Response.php
    │   ├── Router.php
    │   ├── Session.php
    │   ├── Setting.php
    │   ├── System.php
    │   └── Template.php
    ├── LogInterface.php
    ├── LogReference.php
    ├── OnceInterface.php
    ├── PathInterface.php
    ├── PathReference.php
    ├── RedirectInterface.php
    ├── RedirectReference.php
    ├── RequestInterface.php
    ├── RequestReference.php
    ├── ResponseInterface.php
    ├── ResponseReference.php
    ├── RouterInterface.php
    ├── RouterReference.php
    ├── ScriptInterface.php
    ├── SessionInterface.php
    ├── SessionReference.php
    ├── SettingInterface.php
    ├── SettingReference.php
    ├── SystemInterface.php
    ├── SystemReference.php
    ├── TemplateInterface.php
    ├── TemplateReference.php
    └── ViewInterface.php
├── Route
    ├── After.php
    ├── Alias.php
    ├── Any.php
    ├── Controller.php
    ├── Delete.php
    ├── Domain.php
    ├── Fallback.php
    ├── Get.php
    ├── Group
    │   ├── EndGroup.php
    │   ├── GroupAfter.php
    │   ├── GroupDomain.php
    │   ├── GroupMiddleware.php
    │   ├── GroupNoDebug.php
    │   ├── GroupPlain.php
    │   ├── GroupPrefix.php
    │   ├── GroupProtect.php
    │   ├── GroupWhere.php
    │   └── ToGroup.php
    ├── MatchTypes.php
    ├── Middleware.php
    ├── Module.php
    ├── Name.php
    ├── NoDebug.php
    ├── Options.php
    ├── Page.php
    ├── Patch.php
    ├── Plain.php
    ├── Post.php
    ├── Protect.php
    ├── Put.php
    ├── Redirect.php
    └── Where.php
├── Static
    ├── Arr.php
    ├── Cache.php
    ├── Command.php
    ├── Container.php
    ├── Converter.php
    ├── Cookies.php
    ├── Csrf.php
    ├── DB.php
    ├── DI.php
    ├── Debug.php
    ├── Log.php
    ├── Once.php
    ├── Path.php
    ├── Redirect.php
    ├── Request.php
    ├── Response.php
    ├── Router.php
    ├── Script.php
    ├── Session.php
    ├── Settings.php
    ├── System.php
    ├── Template.php
    └── View.php
├── bootstrap.php
├── composer.json
├── console.php
├── preload.php
├── readme.md
└── web
    ├── css
        ├── default-origin.css
        ├── default.css
        ├── error-origin.css
        └── error.css
    ├── index.php
    └── svg
        └── logo.svg


/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | 
 2 | #### What steps will reproduce the problem?
 3 | 
 4 | #### What is the expected result?
 5 | 
 6 | #### What do you get instead?
 7 | 
 8 | 
 9 | #### Additional info
10 | 
11 | | Q                 | A             |
12 | |-------------------|---------------|
13 | | Framework version | 2.**?**.**?** |
14 | | PHP version       | 8.**?**       |
15 | | Operating system  |               |
16 | 
17 | ------
18 | _Description of the problem found. For security issues contact maintainers privately._
19 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | | Q            | A                                                         |
 2 | |--------------|-----------------------------------------------------------|
 3 | | Is bugfix?   | **Yes / No**                                              |
 4 | | New feature? | **Yes / No**                                              |
 5 | | Breaks BC?   | **Yes / No**                                              |
 6 | | Fixed issues | comma-separated list of tickets # fixed by the PR, if any |
 7 | 
 8 | ------
 9 | _Description of the changes being made._
10 | 


--------------------------------------------------------------------------------
/.github/SECURITY.md:
--------------------------------------------------------------------------------
1 | # Security Policy
2 | 
3 | -----
4 | Please contact the author to let us know about any security issue you find in the [phphleb](https://github.com/phphleb) repository.
5 | DO NOT use the issue tracker or discuss it in the public forum as it will cause more damage than help.
6 | 
7 | Please note that as a non-commercial OpenSource project we are not able to pay bounties at the moment.


--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | on:
 2 |   push:
 3 |     branches: [ master ]
 4 |   workflow_dispatch:
 5 | 
 6 | name: tests
 7 | 
 8 | jobs:
 9 |   tests:
10 |     name: PHP-${{ matrix.php }}-${{ matrix.os }}
11 | 
12 |     env:
13 |       extensions: json, pdo
14 |       tag: hleb2-php${{ matrix.php }}-${{ matrix.os }}
15 | 
16 |     runs-on: ${{ matrix.os }}
17 | 
18 |     strategy:
19 |       matrix:
20 |         os:
21 |           - ubuntu-latest
22 |           - windows-latest
23 | 
24 |         php:
25 |           - "8.2"
26 |           - "8.3"
27 |           - "8.4"
28 | 
29 |     steps:
30 |       - name: Install PHP with extensions
31 |         uses: shivammathur/setup-php@v2
32 | 
33 |         with:
34 |           php-version: ${{ matrix.php }}
35 |           extensions: ${{ env.extensions }}
36 |           ini-values: date.timezone='UTC'
37 |           coverage: none
38 |           tools: composer:v2
39 | 
40 |       - name: Check PHP
41 |         run: php -v
42 | 
43 |       - name: Install framework
44 |         run: composer create-project phphleb/hleb ./${{ env.tag }}
45 | 
46 |       - name: Framework version
47 |         run: php ./${{ env.tag }}/console --version
48 | 
49 |       - name: Install tests
50 |         run: cd ./${{ env.tag }} && composer require phphleb/tests
51 | 
52 |       - name: Set strict mode
53 |         run: php ./${{ env.tag }}/console reverse-strict-mode-feature --set
54 | 
55 |       - name: Code reduction check
56 |         run: php ./${{ env.tag }}/console clearing-comment-feature
57 | 
58 |       - name: Check autoloader
59 |         run: php ./${{ env.tag }}/console autoloader-support-feature
60 | 
61 |       - name: Run tests
62 |         run: php ./${{ env.tag }}/vendor/phphleb/test-o/run ./vendor/phphleb/tests/
63 | 


--------------------------------------------------------------------------------
/Base/Container.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | use Hleb\Constructor\Containers\ContainerTrait;
12 | 
13 | /**
14 |  * The base class for embedding and using containers in classes that inherit from it.
15 |  * To inherit readonly classes, use ReadonlyContainer.
16 |  *
17 |  * Базовый класс для внедрения и использования контейнеров в наследуемых от него классах.
18 |  * Для наследования readonly классов используйте ReadonlyContainer.
19 |  */
20 | #[AvailableAsParent]
21 | abstract class Container
22 | {
23 |     use ContainerTrait;
24 | }
25 | 


--------------------------------------------------------------------------------
/Base/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | 
12 | /**
13 |  * The base class of the controller, all controllers must inherit from it.
14 |  *
15 |  * Базовый класс контроллера, все контроллеры должны быть унаследованы от него.
16 |  */
17 | #[AvailableAsParent]
18 | abstract class Controller extends Container
19 | {
20 |     public function __construct(#[\SensitiveParameter] array $config = [])
21 |     {
22 |         // The parent constructor must always be initialized first.
23 |         // Сначала всегда должна идти инициализация родительского конструктора.
24 |         parent::__construct($config);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Base/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | 
12 | /**
13 |  * Parent class for events.
14 |  *
15 |  * Родительский класс для событий.
16 |  */
17 | #[AvailableAsParent]
18 | abstract class Event extends Container
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/Base/Middleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | 
12 | /**
13 |  * The base class of the middleware controller,
14 |  * all middleware controllers must be inherited from it.
15 |  *
16 |  * Базовый класс контроллера-посредника (middleware),
17 |  * все контроллеры-посредники должны быть унаследованы от него.
18 |  */
19 | #[AvailableAsParent]
20 | abstract class Middleware extends Container
21 | {
22 |     public function __construct(#[\SensitiveParameter] array $config = [])
23 |     {
24 |         // The parent constructor must always be initialized first.
25 |         // Сначала всегда должна идти инициализация родительского конструктора.
26 |         parent::__construct($config);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Base/Model.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | use Hleb\Constructor\Models\ModelTrait;
12 | 
13 | /**
14 |  * The base class of the model, all Models must be inherited from it.
15 |  * To inherit readonly classes, use ReadonlyModel.
16 |  *
17 |  * Базовый класс модели, все Модели должны быть унаследованы от него.
18 |  * Для наследования readonly классов используйте ReadonlyModel.
19 |  */
20 | #[AvailableAsParent]
21 | abstract class Model
22 | {
23 |     use ModelTrait;
24 | }
25 | 


--------------------------------------------------------------------------------
/Base/Module.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | 
12 | /**
13 |  * The base class for the module controller, all module controllers must inherit from it.
14 |  *
15 |  * Базовый класс для контроллера модуля, все контроллеры модуля должны быть унаследованы от него.
16 |  */
17 | #[AvailableAsParent]
18 | abstract class Module extends Container
19 | {
20 |     public function __construct(#[\SensitiveParameter] array $config = [])
21 |     {
22 |         // The parent constructor must always be initialized first.
23 |         // Сначала всегда должна идти инициализация родительского конструктора.
24 |         parent::__construct($config);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Base/ReadonlyContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | use Hleb\Constructor\Containers\ContainerTrait;
12 | 
13 | /**
14 |  * The base readonly class for embedding and using containers in readonly classes that inherit from it.
15 |  * To inherit non-readonly classes, use Container.
16 |  *
17 |  * Базовый readonly класс для внедрения и использования контейнеров в наследуемых от него readonly классах.
18 |  * Для наследования не-readonly классов используйте Container.
19 |  */
20 | #[AvailableAsParent]
21 | abstract readonly class ReadonlyContainer
22 | {
23 |    use ContainerTrait;
24 | }
25 | 


--------------------------------------------------------------------------------
/Base/ReadonlyModel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | namespace Hleb\Base;
 9 | 
10 | use Hleb\Constructor\Attributes\AvailableAsParent;
11 | use Hleb\Constructor\Models\ModelTrait;
12 | 
13 | /**
14 |  * The base class of the model, all Models must be inherited from it.
15 |  * To inherit non-readonly classes, use Model.
16 |  *
17 |  * Базовый класс модели, все Модели должны быть унаследованы от него.
18 |  * Для наследования не-readonly классов используйте Model.
19 |  */
20 | #[AvailableAsParent]
21 | abstract readonly class ReadonlyModel
22 | {
23 |     use ModelTrait;
24 | }
25 | 


--------------------------------------------------------------------------------
/Constructor/Actions/ActionInterface.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Hleb\Constructor\Actions;
4 | 
5 | interface ActionInterface
6 | {
7 |     public function run(): void;
8 | }
9 | 


--------------------------------------------------------------------------------
/Constructor/Actions/ClearCacheAction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Constructor\Actions;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\CoreProcessException;
 9 | use Hleb\Reference\CacheReference;
10 | 
11 | #[Accessible]
12 | final class ClearCacheAction implements ActionInterface
13 | {
14 |     /**
15 |      * Clearing the entire framework cache.
16 |      *
17 |      * Очистка всего кеша фреймворка.
18 |      */
19 |     #[\Override]
20 |    public function run(): void
21 |    {
22 |        if (!(new CacheReference())->clear()) {
23 |            throw new CoreProcessException('Failed to clear cache.');
24 |        }
25 |    }
26 | }
27 | 


--------------------------------------------------------------------------------
/Constructor/Actions/UpdateRouteCacheAction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Constructor\Actions;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Cache\CacheRoutes;
 9 | use Hleb\CoreProcessException;
10 | use Hleb\RouteColoredException;
11 | use Hleb\Main\Routes\Update\RouteData;
12 | 
13 | #[Accessible]
14 | final class UpdateRouteCacheAction implements ActionInterface
15 | {
16 |     /**
17 |      * Route cache update.
18 |      *
19 |      * Обновление кеша маршрутов.
20 |      */
21 |     #[\Override]
22 |     public function run(): void
23 |     {
24 |         try {
25 |             (new CacheRoutes((new RouteData())->dataExtraction()))->save();
26 |         } catch (RouteColoredException $e) {
27 |             throw new CoreProcessException($e->getError());
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Accessible.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * The #[Accessible] tag for a framework class indicates that
 7 |  * its methods or an instance of the class are available
 8 |  * for use in user code.
 9 |  * Use depends on the purpose of the class.
10 |  *
11 |  * При помощи метки #[Accessible] для класса фреймворка указывается,
12 |  * что его методы или экземпляр класса доступны для использования
13 |  * в пользовательском коде.
14 |  * Использование зависит от предназначения класса.
15 |  */
16 | #[\Attribute(\Attribute::TARGET_CLASS)]
17 | class Accessible
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Autowiring/AllowAutowire.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes\Autowiring;
 4 | 
 5 | /**
 6 |  * The #[AllowAutowire] tag for a class indicates that it is AVAILABLE
 7 |  * for substitution during dependency injection.
 8 |  * Relevant only when a certain DI mode is enabled
 9 |  * in the configuration (disabled if this attribute is not present).
10 |  * The condition does not apply to classes of services
11 |  * located in the container.
12 |  *
13 |  * При помощи метки #[AllowAutowire] для класса указывается,
14 |  * что он ДОСТУПЕН для подстановки при внедрении зависимостей.
15 |  * Актуально только при включении определенного режима DI
16 |  * в конфигурации (выключено, если нет этого атрибута).
17 |  * Условие не касается классов находящихся в контейнере сервисов.
18 |  */
19 | #[\Attribute(\Attribute::TARGET_CLASS)]
20 | class AllowAutowire
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Autowiring/Config.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Constructor\Attributes\Autowiring;
 6 | 
 7 | /**
 8 |  * Provides the ability to set the required value for auto-substitution
 9 |  * from the framework configuration by type (name) of the configuration and key.
10 |  * Can be used to automatically resolve dependencies.
11 |  *
12 |  * Предоставляет возможность задать необходимое значение для авто-подстановки
13 |  * из конфигурации фреймворка по типу(названию) конфигурации и ключа.
14 |  * Может быть применен для автоматического разрешения зависимостей.
15 |  */
16 | #[\Attribute(\Attribute::TARGET_PARAMETER)]
17 | readonly class Config
18 | {
19 |     /**
20 |      * Setting up a substitution for the Dependency Injection parameter.
21 |      *
22 |      * Установка подмены для Dependency Injection параметра.
23 |      *
24 |      *  ```php
25 |      *  class ExampleController extends Controller
26 |      *  {
27 |      *      public function index(
28 |      *          #[Config('main', 'default.lang')]
29 |      *          string $defaultLanguage,
30 |      *      ) {
31 |      *        //...//
32 |      *      }
33 |      *  }
34 |      * ```
35 |      *
36 |      * @param string $name - the name of the configuration type, for example 'common'.
37 |      *                     - название типа конфигурации, например 'common'.
38 |      *
39 |      * @param string $key - key to get the value.
40 |      *                    - ключ для получения значения.
41 |      */
42 |     public function __construct(public string $name, public string $key)
43 |     {
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Autowiring/NoAutowire.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes\Autowiring;
 4 | 
 5 | /**
 6 |  * The #[NoAutowire] label for a class indicates that
 7 |  * it is NOT AVAILABLE for dependency injection substitution.
 8 |  * Relevant only when a specific DI mode is enabled
 9 |  * in the configuration (enabled if this attribute is not present).
10 |  * The condition does not apply to classes of services
11 |  * located in the container.
12 |  *
13 |  * При помощи метки #[NoAutowire] для класса указывается,
14 |  * что он НЕ ДОСТУПЕН для подстановки при внедрении зависимостей.
15 |  * Актуально только при включении определенного режима DI
16 |  * в конфигурации (включено, если нет этого атрибута).
17 |  * Условие не касается классов находящихся в контейнере сервисов.
18 |  */
19 | #[\Attribute(\Attribute::TARGET_CLASS)]
20 | class NoAutowire
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/AvailableAsParent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * Using the #[AvailableAsParent] tag for a framework class,
 7 |  * it is indicated that it is accessible from the outside
 8 |  * for classes in user code to inherit from it.
 9 |  * Inheritance depends on the purpose of a particular class.
10 |  *
11 |  * При помощи метки #[AvailableAsParent] для класса фреймворка
12 |  * указывается, что он доступен извне для наследования от него
13 |  * классов в пользовательском коде.
14 |  * Наследование зависит от предназначения конкретного класса.
15 |  */
16 | #[\Attribute(\Attribute::TARGET_CLASS)]
17 | class AvailableAsParent
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Dependency.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * The #[Dependency] tag denotes a framework class
 7 |  * that is waiting for external code to be added
 8 |  * to the implementation of a particular functionality.
 9 |  * The existence and naming of this class in the project
10 |  * is as necessary as the presence of the library
11 |  * of the framework itself.
12 |  *
13 |  * Меткой #[Dependency] обозначается класс фреймворка,
14 |  * ожидающий внесения внешнего кода в реализацию
15 |  * той или иной функциональности.
16 |  * Существование и именование этого класса в проекте
17 |  * так-же обязательно, как и наличие библиотеки
18 |  * самого фреймворка.
19 |  */
20 | #[\Attribute(\Attribute::TARGET_CLASS)]
21 | class Dependency
22 | {
23 | }
24 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Disabled.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * By using the #[Disabled] label on a class or method,
 7 |  * you can indicate that it is inactive.
 8 |  * In this case, the interpretation of such a state
 9 |  * is transferred to the label handler.
10 |  *
11 |  * При помощи метки #[Disabled] для класса или метода
12 |  * можно указать, что он неактивен.
13 |  * При этом трактовка такого состояния
14 |  * перекладывается на обработчик метки.
15 |  */
16 | #[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD)]
17 | class Disabled
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/ForTestOnly.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * Marking classes or methods as intended for testing only.
 7 |  *
 8 |  * Пометка классов или методов предназначенных только для тестирования.
 9 |  */
10 | #[\Attribute]
11 | class ForTestOnly
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/Hidden.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * By using the #[Hidden] label on a class or method
 7 |  * the hiding from the given visibility is defined.
 8 |  * In this case, the interpretation of such a state
 9 |  * is transferred to the label handler.
10 |  *
11 |  * При помощи метки #[Hidden] для класса или метода
12 |  * определяется скрытие из заданной видимости.
13 |  * При этом трактовка такого состояния
14 |  * перекладывается на обработчик метки.
15 |  */
16 | #[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD)]
17 | class Hidden
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/Constructor/Attributes/NotFinal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Attributes;
 4 | 
 5 | /**
 6 |  * You can use the #[NotFinal] tag on a class or method
 7 |  * to indicate that it should not be final.
 8 |  *
 9 |  * При помощи метки #[NotFinal] для класса или метода
10 |  * можно указать, что он не должен быть финальным.
11 |  */
12 | #[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD)]
13 | class NotFinal
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/Constructor/Cache/OnceResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Constructor\Cache;
 6 | 
 7 | use Hleb\DynamicStateException;
 8 | 
 9 | /**
10 |  * The class contains the execution logic for the once() function,
11 |  * which allows a piece of specific code to be executed once per request.
12 |  *
13 |  * Класс содержит логику выполнения для функции once(),
14 |  * она позволяет выполнять часть определенного кода один раз за запрос.
15 |  */
16 | final class OnceResult
17 | {
18 |     private static array $data = [];
19 | 
20 |     /**
21 |      * @see once()
22 |      *
23 |      * @internal
24 |      */
25 |     public static function get(callable $func): mixed
26 |     {
27 |         $backtrace = \debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3);
28 |         $pos = $backtrace[2] ?? null;
29 | 
30 |         if (empty($pos) || $pos['function'] !== 'once') {
31 |             throw new DynamicStateException('Incorrect use of the once() function');
32 |         }
33 | 
34 |         $key = $pos['file'] . ':' . $pos['line'];
35 | 
36 |         if (\array_key_exists($key, self::$data)) {
37 |             return self::$data[$key];
38 |         }
39 | 
40 |         return self::$data[$key] = $func();
41 |     }
42 | 
43 |     /**
44 |      * @internal
45 |      */
46 |     public static function rollback(): void
47 |     {
48 |         self::$data = [];
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/Constructor/Containers/TestContainerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Constructor\Containers;
 4 | 
 5 | /**
 6 |  * Interface for replacing methods of the Hleb\Static\Container class in tests.
 7 |  *
 8 |  * Интерфейс для подмены методов класса Hleb\Static\Container в тестах.
 9 |  */
10 | interface TestContainerInterface
11 | {
12 |     /**
13 |      * Getting a custom container by ID.
14 |      *
15 |      * Получение пользовательского контейнера по идентификатору.
16 |      */
17 |     public function get(string $id);
18 | 
19 |     /**
20 |      * Checking if a container exists by ID.
21 |      *
22 |      * Проверка существования контейнера по ID.
23 |      */
24 |     public function has(string $id): bool;
25 | 
26 |     /**
27 |      * Returns the configured Model container or its replacement (for tests).
28 |      *
29 |      * Возвращает сконфигурированный контейнер Модели или его замену (для тестов).
30 |      */
31 |     public static function getContainer(): \App\Bootstrap\ContainerInterface;
32 | 
33 |     /**
34 |      * (!)Forced cleaning of containers.
35 |      * Can be used at the end of an asynchronous request to check for problems
36 |      * with containers. Otherwise, the use of this operation is not recommended.
37 |      * Cleaning the contents of containers is already implemented in the framework.
38 |      *
39 |      * (!)Принудительная очистка контейнеров.
40 |      * Может применяться в конце асинхронного запроса для проверки проблем
41 |      * с контейнерами. В остальном применение этой операции не рекомендуется.
42 |      * Очистка содержимого контейнеров уже реализована во фреймворке.
43 |      */
44 |     public static function rollback(): void;
45 | }
46 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Cause/DomainException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Error when the value does not match the set restrictions in the code.
 9 |  * Also used for various parameter checks, when the parameters are of the desired types,
10 |  * but do not pass the value test.
11 |  *
12 |  * Ошибка при несоответствии значения установленным ограничениям в коде.
13 |  * Также используется для различных проверок параметров, когда параметры нужных типов,
14 |  * но при этом не проходят проверку на значение.
15 |  *
16 |  * @see \LogicException - base SPL class.
17 |  *                      - базовый SPL-класс.
18 |  */
19 | #[NotFinal]
20 | class DomainException extends \DomainException implements CoreException
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Cause/DynamicStateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * An error if the data in the function/method or they themselves are ill-formed.
 9 |  * In a framework, these can be functions/methods created at runtime,
10 |  * whose input parameters are initially unknown.
11 |  *
12 |  * Ошибка в случае, если данные в функции/методе или они сами некорректно сформированы.
13 |  * Во фреймворке это могут быть  функции/методы, создаваемые в процессе выполнения,
14 |  * входные параметры которых изначально не известны.
15 |  *
16 |  * @see \RuntimeException - base SPL class.
17 |  *                        - базовый SPL-класс.
18 |  */
19 | #[NotFinal]
20 | class DynamicStateException extends CoreProcessException
21 | {
22 | }
23 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Cause/InvalidArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Error if the expected arguments in the function/method are malformed.
 9 |  * The data is already erroneous before the execution
10 |  * of a specific block of code that expects this data.
11 |  *
12 |  * Ошибка в случае, если ожидаемые аргументы в функции/методе некорректно сформированы.
13 |  * Данные ошибочны уже до выполнения конкретного блока кода, ожидающего эти данные.
14 |  *
15 |  * @see \LogicException - base SPL class.
16 |  *                      - базовый SPL-класс.
17 |  */
18 | #[NotFinal]
19 | class InvalidArgumentException extends \InvalidArgumentException implements CoreException
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Cause/ParseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Format error while parsing data.
 9 |  *
10 |  * Ошибка формата при разборе данных.
11 |  *
12 |  * @see \RuntimeException - base SPL class.
13 |  *                        - базовый SPL-класс.
14 |  */
15 | #[NotFinal]
16 | class ParseException extends CoreProcessException
17 | {
18 | }
19 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Cause/UnexpectedValueException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * An error occurs when a block of code returns a value that it shouldn't.
 9 |  *
10 |  * Ошибка, когда блок кода возвращает значение, которое не должен возвращать.
11 |  *
12 |  * @see \RuntimeException - base SPL class.
13 |  *                        - базовый SPL-класс.
14 |  */
15 | #[NotFinal]
16 | class UnexpectedValueException extends \UnexpectedValueException implements CoreException
17 | {
18 | }
19 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/CoreErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * A fatal error in the core of the framework,
 9 |  * which occurred due to errors in the code itself,
10 |  * and not during its execution.
11 |  *
12 |  * Фатальная ошибка в ядре фреймворка,
13 |  * которая возникла при ошибках в самом коде,
14 |  * а не при его выполнении.
15 |  */
16 | #[NotFinal]
17 | class CoreErrorException extends \Exception implements CoreException
18 | {
19 | }
20 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/CoreException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | /**
 6 |  * An exception was thrown in the core of the framework.
 7 |  *
 8 |  * Исключение возникло в ядре фреймворка.
 9 |  */
10 | interface CoreException extends FrameworkException
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/CoreProcessException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * An error in the core framework that occurred during code execution.
 9 |  *
10 |  * Ошибка в ядре фреймворка, которая возникла во время выполнения кода.
11 |  */
12 | #[NotFinal]
13 | class CoreProcessException extends \RuntimeException implements CoreException
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Database/DatabaseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * An exception occurred while working with the database.
 9 |  *
10 |  * Исключение возникло при работе с базой данных.
11 |  *
12 |  * @see \RuntimeException
13 |  */
14 | #[NotFinal]
15 | class DatabaseException extends \PDOException implements CoreException
16 | {
17 | }
18 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/File/FileResourceAccessException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Error accessing a file or folder in the framework.
 9 |  * Occurs when a file or folder is not found
10 |  * or failed to read the content from the file.
11 |  *
12 |  * Ошибка обращения к файлу или папке во фреймворке.
13 |  * Возникает, когда файл или папка не найдены
14 |  * или не получилось прочитать контент из файла.
15 |  *
16 |  */
17 | #[NotFinal]
18 | class FileResourceAccessException extends CoreProcessException implements FileSystemException
19 | {
20 | }
21 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/File/FileResourceModificationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Error modifying a file or folder in the framework.
 9 |  * Occurs not only when the file data is changed,
10 |  * but also when the path to the file or folder is changed,
11 |  * as well as when they are deleted or when access rights are changed.
12 |  *
13 |  * Ошибка модификации файла или папки во фреймворке.
14 |  * Возникает не только при изменении данных файла,
15 |  * но и изменения пути к файлу или папке,
16 |  * а также их удаления или изменения прав доступа.
17 |  */
18 | #[NotFinal]
19 | class FileResourceModificationException extends CoreProcessException implements FileSystemException
20 | {
21 | }
22 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/File/FileSystemException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * Error while working with the file system.
 9 |  *
10 |  * Ошибка при работе с файловой системой.
11 |  */
12 | #[NotFinal]
13 | interface FileSystemException
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/FrameworkException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | /**
 6 |  * The exception was generated with the participation of the framework.
 7 |  *
 8 |  * Исключение сформировано при участии фреймворка.
 9 |  */
10 | interface FrameworkException extends \Throwable
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http400BadRequestException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 400 error template.
11 |  * This response means that the server does not understand the request due to invalid syntax.
12 |  * (!) Returns the standard error formatting by the framework, to change the format
13 |  * you need to create your own class inherited from Hleb\HttpException.
14 |  *
15 |  * Шаблон ошибки 400.
16 |  * Этот ответ означает, что сервер не понимает запрос из-за неверного синтаксиса.
17 |  * (!) Возвращает стандартное оформление ошибки фреймворком,для изменения формата
18 |  * необходимо создать собственный класс, унаследованный от Hleb\HttpException.
19 |  */
20 | #[NotFinal]
21 | class Http400BadRequestException extends HttpException
22 | {
23 |     #[NotFinal]
24 |     public function __construct(string $message = 'Bad Request')
25 |     {
26 |         $this->initException(400, $message);
27 | 
28 |         parent::__construct($message);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http401UnauthorizedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 401 error template.
11 |  * Authentication is required to receive the requested response.
12 |  * The status is similar to the 403 status, but, in this case,
13 |  * authentication is possible.
14 |  * (!) Returns the standard error formatting by the framework,
15 |  * to change the format you need to create your own class
16 |  * inherited from Hleb\HttpException.
17 |  *
18 |  * Шаблон ошибки 401.
19 |  * Для получения запрашиваемого ответа нужна аутентификация.
20 |  * Статус похож на статус 403, но, в этом случае,
21 |  * аутентификация возможна.
22 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
23 |  * для изменения формата необходимо создать собственный класс,
24 |  * унаследованный от Hleb\HttpException.
25 |  */
26 | #[NotFinal]
27 | class Http401UnauthorizedException extends HttpException
28 | {
29 |     #[NotFinal]
30 |     public function __construct(string $message = 'Unauthorized')
31 |     {
32 |         $this->initException(401, $message);
33 | 
34 |         parent::__construct($message);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http403ForbiddenException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 403 error template.
11 |  * The client does not have permission to access the content,
12 |  * so the server refuses to give a proper response.
13 |  * (!) Returns the standard error formatting by the framework,
14 |  * to change the format you need to create your own class
15 |  * inherited from Hleb\HttpException.
16 |  *
17 |  * Шаблон ошибки 403.
18 |  * У клиента нет прав доступа к содержимому,
19 |  * поэтому сервер отказывается дать надлежащий ответ.
20 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
21 |  * для изменения формата необходимо создать собственный класс,
22 |  * унаследованный от Hleb\HttpException.
23 |  */
24 | #[NotFinal]
25 | class Http403ForbiddenException extends HttpException
26 | {
27 |     #[NotFinal]
28 |     public function __construct(string $message = 'Forbidden')
29 |     {
30 |         $this->initException(403, $message);
31 | 
32 |         parent::__construct($message);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http404NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 404 error template.
11 |  * The server cannot find the requested resource.
12 |  * (!) Returns the standard error formatting by the framework,
13 |  * to change the format you need to create your own class
14 |  * inherited from Hleb\HttpException.
15 |  *
16 |  * Шаблон ошибки 404.
17 |  * Сервер не может найти запрашиваемый ресурс.
18 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
19 |  * для изменения формата необходимо создать собственный класс,
20 |  * унаследованный от Hleb\HttpException.
21 |  */
22 | #[NotFinal]
23 | class Http404NotFoundException extends HttpException
24 | {
25 |     #[NotFinal]
26 |     public function __construct(string $message = 'Not Found')
27 |     {
28 |         $this->initException(404, $message);
29 | 
30 |         parent::__construct($message);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http406NotAcceptableException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 406 error template.
11 |  * The requested URI cannot satisfy the characteristics passed in the header.
12 |  * (!) Returns the standard error formatting by the framework,
13 |  * to change the format you need to create your own class
14 |  * inherited from Hleb\HttpException.
15 |  *
16 |  * Шаблон ошибки 406.
17 |  * запрошенный URI не может удовлетворить переданным в заголовке характеристикам.
18 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
19 |  * для изменения формата необходимо создать собственный класс,
20 |  * унаследованный от Hleb\HttpException.
21 |  */
22 | #[NotFinal]
23 | class Http406NotAcceptableException extends HttpException
24 | {
25 |     #[NotFinal]
26 |     public function __construct(string $message = 'Not Acceptable')
27 |     {
28 |         $this->initException(406, $message);
29 | 
30 |         parent::__construct($message);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http409ConflictException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 409 error template.
11 |  * The request could not be completed due to a conflicting resource access.
12 |  * (!) Returns the standard error formatting by the framework,
13 |  * to change the format you need to create your own class
14 |  * inherited from Hleb\HttpException.
15 |  *
16 |  * Шаблон ошибки 409.
17 |  * Запрос не может быть выполнен из-за конфликтного обращения к ресурсу.
18 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
19 |  * для изменения формата необходимо создать собственный класс,
20 |  * унаследованный от Hleb\HttpException.
21 |  */
22 | #[NotFinal]
23 | class Http409ConflictException extends HttpException
24 | {
25 |     #[NotFinal]
26 |     public function __construct(string $message = 'Conflict')
27 |     {
28 |         $this->initException(409, $message);
29 | 
30 |         parent::__construct($message);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http410GoneException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 410 error template.
11 |  * The server sends this response if the resource used to be at the specified URL,
12 |  * but was deleted and is now unavailable.
13 |  * (!) Returns the standard error formatting by the framework,
14 |  * to change the format you need to create your own class
15 |  * inherited from Hleb\HttpException.
16 |  *
17 |  * Шаблон ошибки 410.
18 |  * Такой ответ сервер посылает, если ресурс раньше был по указанному URL,
19 |  * но был удалён и теперь недоступен.
20 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
21 |  * для изменения формата необходимо создать собственный класс,
22 |  * унаследованный от Hleb\HttpException.
23 |  */
24 | #[NotFinal]
25 | class Http410GoneException extends HttpException
26 | {
27 |     #[NotFinal]
28 |     public function __construct(string $message = 'Gone')
29 |     {
30 |         $this->initException(410, $message);
31 | 
32 |         parent::__construct($message);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http429TooManyRequestsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 429 error template.
11 |  * The user has sent too many requests in a given amount of time ("rate limiting").
12 |  * (!) Returns the standard error formatting by the framework,
13 |  * to change the format you need to create your own class
14 |  * inherited from Hleb\HttpException.
15 |  *
16 |  * Шаблон ошибки 429.
17 |  * Пользователь отправил слишком много запросов за определённый промежуток времени (ограничение на частоту запросов).
18 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
19 |  * для изменения формата необходимо создать собственный класс,
20 |  * унаследованный от Hleb\HttpException.
21 |  */
22 | #[NotFinal]
23 | class Http429TooManyRequestsException extends HttpException
24 | {
25 |     #[NotFinal]
26 |     public function __construct(string $message = 'Too Many Requests')
27 |     {
28 |         $this->initException(429, $message);
29 | 
30 |         parent::__construct($message);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http500InternalServerErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 500 error template.
11 |  * This response means that there was a runtime error on the server.
12 |  * (!) Returns the standard error formatting by the framework, to change the format
13 |  * you need to create your own class inherited from Hleb\HttpException.
14 |  *
15 |  * Шаблон ошибки 500.
16 |  * Этот ответ означает, что возникла ошибка на стороне сервера.
17 |  * (!) Возвращает стандартное оформление ошибки фреймворком,для изменения формата
18 |  * необходимо создать собственный класс, унаследованный от Hleb\HttpException.
19 |  */
20 | #[NotFinal]
21 | class Http500InternalServerErrorException extends HttpException
22 | {
23 |     #[NotFinal]
24 |     public function __construct(string $message = 'Internal Server Error')
25 |     {
26 |         $this->initException(500, $message);
27 | 
28 |         parent::__construct($message);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Http/Http503ServiceUnavailableException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | 
 9 | /**
10 |  * 503 error template.
11 |  * The server is not ready to handle the request. Common causes are
12 |  * a server that is down for maintenance or that is overloaded.
13 |  * (!) Returns the standard error formatting by the framework,
14 |  * to change the format you need to create your own class
15 |  * inherited from Hleb\HttpException.
16 |  *
17 |  * Шаблон ошибки 503.
18 |  * Сервер не готов обработать запрос. Распространённые причины — сервер на обслуживании или перегружен.
19 |  * (!) Возвращает стандартное оформление ошибки фреймворком,
20 |  * для изменения формата необходимо создать собственный класс,
21 |  * унаследованный от Hleb\HttpException.
22 |  */
23 | #[NotFinal]
24 | class Http503ServiceUnavailableException extends HttpException
25 | {
26 |     #[NotFinal]
27 |     public function __construct(string $message = 'Service Unavailable')
28 |     {
29 |         $this->initException(503, $message);
30 | 
31 |         parent::__construct($message);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/HttpException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb;
 6 | 
 7 | use Hleb\Constructor\Attributes\NotFinal;
 8 | use Hleb\Main\BaseErrorPage;
 9 | use RuntimeException;
10 | 
11 | /**
12 |  * Allows you to display standard HTTP errors of the framework.
13 |  * All inherited error classes will be treated as HTTP errors by the framework.
14 |  *
15 |  * Позволяет выводить стандартные HTTP-ошибки фреймворка.
16 |  * Все унаследованные классы ошибок будут обработаны фреймворком как HTTP-ошибки.
17 |  */
18 | #[NotFinal]
19 | abstract class HttpException extends RuntimeException implements CoreException
20 | {
21 |     /**
22 |      * HTTP error code.
23 |      *
24 |      * HTTP-код ошибки.
25 |      */
26 |     protected int $httpCode;
27 | 
28 |     /**
29 |      * HTML error code or any other text such as JSON.
30 |      *
31 |      * HTML-код ошибки или любой другой текст, например JSON.
32 |      */
33 |     protected string $messageContent;
34 | 
35 |     /** @internal */
36 |     public function getHttpStatus(): int
37 |     {
38 |         return $this->httpCode;
39 |     }
40 | 
41 |     /** @internal */
42 |     public function getMessageContent(): string
43 |     {
44 |         return $this->messageContent;
45 |     }
46 | 
47 |     /**
48 |      * Method for displaying standard error handling by the framework.
49 |      *
50 |      * Метод для вывода стандартного оформления ошибки фреймворком.
51 |      */
52 |     protected function initException(int $httpCode, string $message): void
53 |     {
54 |         $this->httpCode = $httpCode;
55 | 
56 |         $this->messageContent = (new BaseErrorPage($httpCode, $message))->insert();
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Log/InvalidLogLevelException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | #[NotFinal]
 8 | class InvalidLogLevelException extends CoreProcessException
 9 | {
10 | }
11 | 


--------------------------------------------------------------------------------
/Constructor/Exceptions/Reflection/ReflectionProcessException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb;
 4 | 
 5 | use Hleb\Constructor\Attributes\NotFinal;
 6 | 
 7 | /**
 8 |  * An error occurred when applying reflection as a result of code execution.
 9 |  *
10 |  * Ошибка применения рефлексии в результате выполнения кода.
11 |  */
12 | #[NotFinal]
13 | class ReflectionProcessException extends CoreProcessException
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/Constructor/Models/ModelTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Constructor\Models;
 6 | 
 7 | use App\Bootstrap\ContainerInterface;
 8 | use Hleb\Reference\SettingInterface;
 9 | use Hleb\Static\Container;
10 | 
11 | trait ModelTrait
12 | {
13 |     /**
14 |      * Get the model container directly for static methods.
15 |      * Can be called like this:
16 |      *
17 |      * Прямое получение контейнера модели для статических методов.
18 |      * Может быть вызван так:
19 |      *
20 |      * self::container()->db() / self::container()->get(DbInterface::class)
21 |      */
22 |     final protected static function container(): ContainerInterface
23 |     {
24 |         return Container::getContainer();
25 |     }
26 | 
27 |     /**
28 |      * Returns the framework settings from the container.
29 |      *
30 |      * Возвращает настройки фреймворка из контейнера.
31 |      */
32 |     final protected static function settings(): SettingInterface
33 |     {
34 |         return self::container()->get(SettingInterface::class);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Constructor/Templates/PhpTemplate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Constructor\Templates;
 6 | 
 7 | use Hleb\Constructor\Data\SystemSettings;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class PhpTemplate implements TemplateInterface
13 | {
14 |     public function __construct(
15 |         private string $path,
16 |         private array $data,
17 |     )
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * Template output with data injection.
23 |      *
24 |      * Вывод шаблона с внедрением данных.
25 |      */
26 |     public function view(): void
27 |     {
28 |         \extract($this->data);
29 |         unset($this->data);
30 |         if (!\str_ends_with($this->path, '.php')) {
31 |             $this->path = "{$this->path}.php";
32 |         }
33 | 
34 |         require SystemSettings::getRealPath($this->path);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Constructor/Templates/TemplateInterface.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Hleb\Constructor\Templates;
4 | 
5 | interface TemplateInterface
6 | {
7 |    public function view(): void;
8 | }
9 | 


--------------------------------------------------------------------------------
/Helpers/Abracadabra.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Random\Randomizer;
 9 | 
10 | #[Accessible]
11 | final class Abracadabra
12 | {
13 |     private const BASE_SYMBOLS = 'ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba9876543210';
14 | 
15 |     private const SPECIAL_SYMBOLS = '-@#$_%&.~=';
16 | 
17 |     /**
18 |      * Generates an unpredictable set of random characters.
19 |      * Suitable for various kinds of rarely generated keys.
20 |      *
21 |      * Генерирует непредсказуемый набор случайных символов.
22 |      * Подходит для различного рода редко генерируемых ключей.
23 |      */
24 |     public static function generate(int $length = 64, bool $extended = false): string
25 |     {
26 |         $length < 5 and $length = 5;
27 |         $symbols = $extended ? self::BASE_SYMBOLS . self::SPECIAL_SYMBOLS : self::BASE_SYMBOLS;
28 | 
29 |         if (PHP_VERSION_ID < 80300) {
30 |             $key = '';
31 |             $sampleLast = \strlen($symbols) - 1;
32 |             for ($i = 0; $i < $length; $i++) {
33 |                 $key .= $symbols[\rand(0, $sampleLast)];
34 |             }
35 | 
36 |             return $key;
37 |         }
38 | 
39 |         return (new Randomizer())->getBytesFromString($symbols, $length);
40 |     }
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/Helpers/DefaultValueHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\DomainException;
 8 | use Throwable;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class DefaultValueHelper
14 | {
15 |     /**
16 |      * Allows the use of an error class in the value to indicate that the parameter is missing.
17 |      *
18 |      * Разрешает использовать в значении класс ошибки для обозначения параметра отсутствующим.
19 |      *
20 |      * @throws Throwable
21 |      */
22 |     public static function err(bool|string $exc, string $text = 'A required parameter is missing.'): void
23 |     {
24 |         if ($exc === false) {
25 |             return;
26 |         }
27 |         if ($exc === true) {
28 |             throw new DomainException($text);
29 |         }
30 |         if (\class_exists($exc) && \is_subclass_of($exc, Throwable::class)) {
31 |             throw new $exc($text);
32 |         }
33 |         throw new \RuntimeException("The class $exc should be an exception.");
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Helpers/HostHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | 
 9 | #[Accessible]
10 | final class HostHelper
11 | {
12 |     /**
13 |      * Returns the result of checking whether the specified host is localhost.
14 |      *
15 |      * Возвращает результат проверки - является ли указанный хост localhost.
16 |      */
17 |     public static function isLocalhost(string $host): bool
18 |     {
19 |         if (\in_array($host, ['localhost', '127.0.0.1', '::1'])) {
20 |             return true;
21 |         }
22 |         if (\str_starts_with($host, 'localhost:')) {
23 |             return true;
24 |         }
25 |         if (\str_starts_with($host, '127.0.0.')) {
26 |             return true;
27 |         }
28 |         return false;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Helpers/NameConverter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | 
 9 | #[Accessible]
10 | final class NameConverter
11 | {
12 |     /**
13 |      * Converts a string to a class name.
14 |      *
15 |      * Преобразует строку в название класса.
16 |      */
17 |     public function convertStrToClassName(string $str): string
18 |     {
19 |         $str = str_replace('/', '\\', \strtolower($str));
20 |         $str = \implode('\\', \array_map('ucfirst', \explode('\\', $str)));
21 | 
22 |         return \implode(\array_map('ucfirst', \explode('-', $str)));
23 |     }
24 | 
25 |     /**
26 |      * Converts the class name to a hyphenated string.
27 |      *
28 |      * Преобразует название класса в строку с дефисами.
29 |      */
30 |     public function convertClassNameToStr(string $className): string
31 |     {
32 |         if ($className[0] === strtolower($className[0])) {
33 |             return $className;
34 |         }
35 |         $parts = [];
36 |         \preg_match_all('/[A-Z][^A-Z]+/s', $className, $result, PREG_SET_ORDER);
37 |         foreach ($result as $value) {
38 |             $parts[] = $value[0] ?? '';
39 |         }
40 |         return \strtolower(\implode('-', $parts));
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Helpers/PhpCommentHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | 
 9 | /**
10 |  * Removing comments for base cases.
11 |  *
12 |  * Удаление комментариев для базовых случаев.
13 |  */
14 | #[Accessible]
15 | final readonly class PhpCommentHelper
16 | {
17 |     /**
18 |      * Removes single line comments from code that start with `//`.
19 |      *
20 |      * Удаляет однострочные комментарии из кода, которые начинаются с `//`.
21 |      */
22 |     public function clearOneLiner(string $code): string
23 |     {
24 |         return \preg_replace('/^\s*\/\/.*$/m', '', $code);
25 |     }
26 | 
27 |     /**
28 |      * Removing multiline comments.
29 |      *
30 |      * Удаление многострочных комментариев.
31 |      */
32 |     public function clearMultiLine(string $code): string
33 |     {
34 |         return \preg_replace('/^\s*\/\*.*?(\*\/)/ms', '', $code);
35 |     }
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/Helpers/ProtectedFileSaver.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\CoreProcessException;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class ProtectedFileSaver
13 | {
14 |     /**
15 |      * Saving a file with write protection (does not work in all OS).
16 |      *
17 |      * Сохранение файла с защитой от конкурентной записи (работает не во всех OC).
18 |      */
19 |     public function save(string $path, string $data): void
20 |     {
21 |        \hl_create_directory($path);
22 | 
23 |        $fp = \fopen($path, 'wb+');
24 |        if ($fp === false || !\flock($fp, LOCK_EX)) {
25 |            // If for some reason the file cannot be written, it is written without blocking.
26 |            // Если по какой-то причине записать файл не удается, то он записывается без блокировки.
27 |            \file_put_contents($path, $data);
28 |            $fp and \fclose($fp);
29 |            @\chmod($path, 0664);
30 |            return;
31 |        }
32 |        \ftruncate($fp, 0);
33 |        if (!\fwrite($fp, $data)) {
34 |            throw new CoreProcessException('Failed to save the file, check the permissions on the directory.');
35 |        }
36 |        \fflush($fp);
37 |        \flock($fp, LOCK_UN);
38 | 
39 |        \fclose($fp);
40 |         @\chmod($path, 0664);
41 |    }
42 | }
43 | 


--------------------------------------------------------------------------------
/Helpers/ReflectionConstant.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\ReflectionProcessException;
 9 | 
10 | /**
11 |  * A set of methods for obtaining the values of class constants.
12 |  *
13 |  * Набор методов для получения значений констант класса.
14 |  */
15 | #[Accessible]
16 | final class ReflectionConstant
17 | {
18 |     private array $constants = [];
19 | 
20 |     public function __construct(string $className)
21 |     {
22 |         try {
23 |             $method = (new \ReflectionClass($className));
24 |         } catch (\ReflectionException $e) {
25 |             throw new ReflectionProcessException($e);
26 |         }
27 |         $this->constants = $method->getConstants();
28 |     }
29 | 
30 |     public function all(): array
31 |     {
32 |         return $this->constants;
33 |     }
34 | 
35 |     public function get(string $name): mixed
36 |     {
37 |         return $this->constants[$name] ?? false;
38 |     }
39 | 
40 |     public function has(string $name): bool
41 |     {
42 |         return \array_key_exists($name, $this->constants);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Helpers/StrToList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | 
 9 | #[Accessible]
10 | final class StrToList
11 | {
12 |     final public const INT_TYPE = 'int';
13 | 
14 |     final public const STRING_TYPE = 'string';
15 | 
16 |     final public const FLOAT_TYPE = 'float';
17 | 
18 |     final public const BOOL_TYPE = 'bool';
19 | 
20 |     private const TYPES = [
21 |         'string' => 'strval', 'int' => 'intval', 'integer' => 'intval', 'float' => 'floatval', 'double' => 'floatval', 'bool' => 'boolval', 'boolean' => 'boolval'
22 |     ];
23 | 
24 |     /**
25 |      * Converting a comma-separated enum to a list. '1, 2, 3, test' in ['1', '2', '3', 'test'].
26 |      *
27 |      * Преобразование перечисления через запятую в список. '1, 2, 3, test' в ['1', '2', '3', 'test'].
28 |      *
29 |      * @param string $value - original value.
30 |      *                      - исходное значение.
31 |      *
32 |      * @param string $type - type of values in array.
33 |      *                     - тип значений в массиве.
34 |      * @return array
35 |      */
36 |     public static function convert(string $value, string $type = self::STRING_TYPE): array
37 |     {
38 |         if ($value === '') {
39 |             return [];
40 |         }
41 |         return \array_map(self::TYPES[$type], \array_map('trim', \explode(',', $value)));
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Helpers/StringHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Helpers;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | 
 9 | #[Accessible]
10 | final class StringHelper
11 | {
12 |     /**
13 |      * Returns the difference between two strings as an array with errors.
14 |      * A simpler comparison in the standard similar_text() function.
15 |      *
16 |      * Возвращает расхождение двух строк в виде массива с ошибками.
17 |      * Более простое сравнение в стандартной функции similar_text().
18 |      */
19 |     public static function compare(string $first, string $second): array
20 |     {
21 |         if (!$first && !$second) {
22 |             return [];
23 |         }
24 |         $result = [];
25 |         $f = \str_split($first);
26 |         $s = \str_split($second);
27 | 
28 |         foreach ($f as $k => $v) {
29 |             if (!\array_key_exists($k, $s)) {
30 |                 $result[] = ['first' => $v, 'pos' => $k, 'error' => 'not in second', 'err' => 1];
31 |             } else if ($v !== $s[$k]) {
32 |                 $result[] = ['first' => $v, 'second' => $s[$k], 'pos' => $k, 'error' => 'does not match', 'err' => 3];
33 |             }
34 |         }
35 |         for ($i = \count($f); $i < \count($s); $i++) {
36 |             $result[] = ['second' => $s[$i], 'pos' => $i, 'error' => 'not in first', 'err' => 2];
37 |         }
38 |         return $result;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/HttpMethods/Intelligence/Cookies/CookieInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\HttpMethods\Intelligence\Cookies;
 4 | 
 5 | use Hleb\HttpMethods\Specifier\DataType;
 6 | 
 7 | /**
 8 |  * Interface for combining types of work with Cookies.
 9 |  *
10 |  * Интерфейс для объединения типов работы с Cookies.
11 |  *
12 |  * @internal
13 |  */
14 | interface CookieInterface
15 | {
16 |     /**
17 |      * @return  DataType[]
18 |      */
19 |     public static function all(): array;
20 | 
21 |     public static function set(string $name, string $value, array $options = []): void;
22 | 
23 |     public static function get(string $name): DataType;
24 | 
25 |     public static function setSessionName(string $name): void;
26 | 
27 |     public static function getSessionName(): string;
28 | 
29 |     public static function setSessionId(string $id): void;
30 | 
31 |     public static function getSessionId(): string;
32 | 
33 |     public static function delete(string $name): void;
34 | 
35 |     public static function clear(): void;
36 | 
37 |     /** @internal */
38 |     public static function output(): void;
39 | }
40 | 


--------------------------------------------------------------------------------
/HttpMethods/Intelligence/Cookies/ParseCookies.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\HttpMethods\Intelligence\Cookies;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class ParseCookies
11 | {
12 |     /**
13 |      * Search for Cookies in headers and return a standardized array.
14 |      *
15 |      * Поиск Cookie в заголовках и возвращение стандартизированного массива.
16 |      */
17 |     public static function getFromRequestHeaders(
18 |         #[\SensitiveParameter] array $requestHeaders,
19 |     ): array
20 |     {
21 |         $cookies = $requestHeaders['Cookie'] ?? $requestHeaders['cookie'] ?? [];
22 |         if (!\is_array($cookies)) {
23 |             $cookies = \array_map('trim', \explode(';', (string)$cookies));
24 |         }
25 |         return $cookies;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Init/Connectors/PhphlebConnector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | 
 6 | /**
 7 |  * Adding a class autoload path: classname => realpath.
 8 |  *
 9 |  * Добавление пути для автозагрузки класса: classname => realpath.
10 |  */
11 | 
12 | namespace Hleb\Init\Connectors;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | final class PhphlebConnector
18 | {
19 |     public static array $map = [
20 |         'Phphleb\Debugpan\Controllers\AppController' => '/phphleb/debugpan/Controllers/AppController.php',
21 |         'Phphleb\Debugpan\Controllers\ResponseTrait' => '/phphleb/debugpan/Controllers/ResponseTrait.php',
22 |         'Phphleb\Debugpan\Controllers\StateController' => '/phphleb/debugpan/Controllers/StateController.php',
23 |         'Phphleb\Debugpan\InitPanel' => '/phphleb/debugpan/InitPanel.php',
24 |         'Phphleb\Debugpan\Panel\Resources' => '/phphleb/debugpan/Panel/Resources.php',
25 |         'Phphleb\Idnaconv\IdnaConvert' => '/phphleb/idnaconv/IdnaConvert.php',
26 |         'Phphleb\Nicejson\JsonConverter' => '/phphleb/nicejson/JsonConverter.php',
27 |         'Phphleb\TestO\Example\ExampleTest' => '/phphleb/test-o/example/ExampleTest.php',
28 |         'Phphleb\TestO\TestCase' => '/phphleb/test-o/TestCase.php',
29 |         'Phphleb\TestO\Tester' => '/phphleb/test-o/Tester.php',
30 |         'Phphleb\TestO\Tests\ArrayEqualsTest' => '/phphleb/test-o/Tests/ArrayEqualsTest.php',
31 |     ];
32 | 
33 |     public static function add(array $map): void
34 |     {
35 |         self::$map = \array_merge($map, self::$map);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Init/Connectors/Preload/search-functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (!function_exists('search_root')) {
 4 |     /**
 5 |      * Function for searching the root directory outside the framework.
 6 |      *
 7 |      * Функция поиска корневой директории вне фреймворка.
 8 |      *
 9 |      * @internal
10 |      */
11 |     function search_root(): string|false
12 |     {
13 |         $base = __DIR__ . '/../../../../../';
14 |         for ($i = 0; $i < 3; $i++) {
15 |             $search = \realpath($base . '/../') . DIRECTORY_SEPARATOR;
16 |             if (\is_dir($search . 'app') && \is_dir($search . 'routes')) {
17 |                 return $search;
18 |             }
19 |         }
20 |         return false;
21 |     }
22 | }
23 | 
24 | if (!function_exists('search_php_files')) {
25 |     /**
26 |      * A universal function that returns a list of paths to files in the specified directory.
27 |      *
28 |      * Универсальная функция, возвращающая список путей к файлам в указанной директории.
29 |      *
30 |      * @internal
31 |      */
32 |     function search_php_files(string $dir): array
33 |     {
34 |         $result = [];
35 |         $files = new RecursiveIteratorIterator(
36 |             new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS)
37 |         );
38 |         /** @var SplFileInfo $file */
39 |         foreach ($files as $file) {
40 |             if ($file->isFile() && $file->getExtension() === 'php') {
41 |                 $result[] = $file->getRealPath();
42 |             }
43 |         }
44 |         return $result;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Init/Headers/ParsePsrHeaders.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Init\Headers;
 6 | 
 7 | /**
 8 |  * Parsing headers from a PSR-7 Request object.
 9 |  *
10 |  * Разбор заголовков из объекта PSR-7 Request.
11 |  */
12 | class ParsePsrHeaders
13 | {
14 |     public function update(mixed $headers): array
15 |     {
16 |         if (empty($headers)) {
17 |             return [];
18 |         }
19 |         $headers = (array)$headers;
20 | 
21 |         foreach ($headers as $n => $i) {
22 |             // If the list contains duplicate headers by name.
23 |             // Если список содержит дубликаты заголовков по названию.
24 |             if ($i && \is_array($i)) {
25 |                 $headers[$n] = \trim(\implode(',', $i));
26 |             }
27 |         }
28 |         foreach ($headers as $name => $header) {
29 |             if (!\is_array($header)) {
30 |                 $items = [];
31 |                 $header = \trim((string)$header);
32 |                 foreach (\explode(',', $header) as $p) {
33 |                     $r = \trim($p);
34 |                     if (!\in_array($r, $items)) {
35 |                         $items[] = $r;
36 |                     }
37 |                 }
38 |                 $headers[$name] = $items;
39 |             }
40 |         }
41 |         return $headers;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Init/Headers/ParseSwooleHeaders.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Init\Headers;
 6 | 
 7 | class ParseSwooleHeaders
 8 | {
 9 |     public function update(mixed $headers): array
10 |     {
11 |         if (empty($headers)) {
12 |             return [];
13 |         }
14 |         $type = 0;
15 |         foreach ((array)$headers as $name => $header) {
16 |             if (is_int($name) && is_string($header)) {
17 |                 $parts = explode(':', $header);
18 |                 if (count($parts) > 1) {
19 |                     $name = array_shift($parts);
20 |                     $header = explode(',', implode(':', $parts));
21 |                     $type = 1;
22 |                 } else {
23 |                     throw new \InvalidArgumentException('Failed to parse headers.');
24 |                 }
25 |             } else if ($type === 1) {
26 |                 throw new \InvalidArgumentException('Wrong headers format.');
27 |             }
28 |             if (is_string($name) && is_string($header)) {
29 |                 $header = explode(',', $header);
30 |             }
31 |             $headers[$name] = $header;
32 |         }
33 | 
34 |         return $headers;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ArrForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\ArrInterface;
10 | use Hleb\Static\Arr;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ArrForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(ArrInterface $mock): void
18 |    {
19 |        Arr::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Arr::replaceWithMock(null);
28 |     }
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/BaseMockAddOn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\ForTestOnly;
 8 | use Hleb\Main\Insert\BaseSingleton;
 9 | 
10 | /**
11 |  * Allows you to use test objects with a similar interface,
12 |  * which are added to classes from the Static folder
13 |  * and replace the execution of methods.
14 |  *
15 |  * Позволяет использовать тестовые объекты с аналогичным
16 |  * интерфейсом, которые добавляются к классам из папки Static
17 |  * и подменяют выполнение методов.
18 |  */
19 | abstract class BaseMockAddOn extends BaseSingleton
20 | {
21 |     /**
22 |      * After replacing the methods of the object for testing,
23 |      * you will need to return them to their basic execution.
24 |      * This method rolls back the use of a test object that
25 |      * was previously installed.
26 |      * If you are using the Mockery library with phpUnit
27 |      * to create test objects, you must use this method
28 |      * instead of Mockery::close().
29 |      *
30 |      * После подмены методов объекта для тестирования
31 |      * необходимо будет вернуть им базовое выполнение.
32 |      * Этот метод откатывает использование тестового объекта,
33 |      * установленного ранее.
34 |      * Если вы используете библиотеку Mockery совместно
35 |      * с phpUnit для создания тестовых объектов, то необходимо
36 |      * использовать этот метод вместо Mockery::close().
37 |      *
38 |      * @see Mock::cancel() - rollback of all replacement objects.
39 |      *                     - откат всех подменных объектов.
40 |      */
41 |     #[ForTestOnly]
42 |     abstract public static function cancel(): void;
43 | }
44 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/CacheForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\CacheInterface;
10 | use Hleb\Static\Cache;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class CacheForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(CacheInterface $mock): void
18 |    {
19 |        Cache::replaceWithMock($mock);
20 |    }
21 | 
22 |    /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Cache::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/CommandForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\CommandInterface;
10 | use Hleb\Static\Command;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class CommandForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(CommandInterface $mock): void
18 |    {
19 |        Command::replaceWithMock($mock);
20 |    }
21 | 
22 |    /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Command::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ContainerForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Constructor\Containers\TestContainerInterface;
10 | use Hleb\Static\Container;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ContainerForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(TestContainerInterface $mock): void
18 |    {
19 |        Container::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Container::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ConverterForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\ConverterInterface;
10 | use Hleb\Static\Converter;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ConverterForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(ConverterInterface $mock): void
18 |    {
19 |        Converter::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Converter::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/CookiesForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\CookieInterface;
10 | use Hleb\Static\Cookies;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class CookiesForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(CookieInterface $mock): void
18 |    {
19 |        Cookies::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Cookies::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/CsrfForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\CsrfInterface;
10 | use Hleb\Static\Csrf;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class CsrfForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(CsrfInterface $mock): void
18 |    {
19 |        Csrf::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Csrf::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/DbForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\DbInterface;
10 | use Hleb\Static\DB;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class DbForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(DbInterface $mock): void
18 |    {
19 |        DB::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         DB::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/DebugForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\DebugInterface;
10 | use Hleb\Static\Debug;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class DebugForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(DebugInterface $mock): void
18 |    {
19 |        Debug::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Debug::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/DiForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\DiInterface;
10 | use Hleb\Static\DI;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class DiForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(DiInterface $mock): void
18 |    {
19 |        DI::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         DI::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/LogForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\LogInterface;
10 | use Hleb\Static\Log;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class LogForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(LogInterface $mock): void
18 |    {
19 |        Log::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Log::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/OnceForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\OnceInterface;
10 | use Hleb\Static\Once;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class OnceForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(OnceInterface $mock): void
18 |    {
19 |        Once::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Once::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/PatchForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\PathInterface;
10 | use Hleb\Static\Path;
11 | 
12 | 
13 | /** @inheritDoc */
14 | #[ForTestOnly] #[Accessible]
15 | final class PatchForTest extends BaseMockAddOn
16 | {
17 |     #[ForTestOnly]
18 |    public static function set(PathInterface $mock): void
19 |    {
20 |        Path::replaceWithMock($mock);
21 |    }
22 | 
23 |     /** @inheritDoc */
24 |     #[ForTestOnly]
25 |     #[\Override]
26 |     public static function cancel(): void
27 |     {
28 |         Path::replaceWithMock(null);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/RedirectForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\RedirectInterface;
10 | use Hleb\Static\Redirect;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class RedirectForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(RedirectInterface $mock): void
18 |    {
19 |        Redirect::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Redirect::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/RequestForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\RequestInterface;
10 | use Hleb\Static\Request;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class RequestForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(RequestInterface $mock): void
18 |    {
19 |        Request::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Request::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ResponseForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\ResponseInterface;
10 | use Hleb\Static\Response;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ResponseForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(ResponseInterface $mock): void
18 |    {
19 |        Response::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Response::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/RouterForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\RouterInterface;
10 | use Hleb\Static\Router;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class RouterForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(RouterInterface $mock): void
18 |    {
19 |        Router::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Router::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ScriptForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\ScriptInterface;
10 | use Hleb\Static\Script;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ScriptForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(ScriptInterface $mock): void
18 |    {
19 |        Script::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Script::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/SessionForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\SessionInterface;
10 | use Hleb\Static\Session;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class SessionForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(SessionInterface $mock): void
18 |    {
19 |        Session::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Session::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/SettingForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\SettingInterface;
10 | use Hleb\Static\Settings;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class SettingForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(SettingInterface $mock): void
18 |    {
19 |        Settings::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Settings::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/SystemForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\SystemInterface;
10 | use Hleb\Static\System;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class SystemForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(SystemInterface $mock): void
18 |    {
19 |        System::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         System::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/TemplateForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\TemplateInterface;
10 | use Hleb\Static\Template;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class TemplateForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(TemplateInterface $mock): void
18 |    {
19 |        Template::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         Template::replaceWithMock(null);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Init/ShootOneselfInTheFoot/ViewForTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Init\ShootOneselfInTheFoot;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Attributes\ForTestOnly;
 9 | use Hleb\Reference\ViewInterface;
10 | use Hleb\Static\View;
11 | 
12 | /** @inheritDoc */
13 | #[ForTestOnly] #[Accessible]
14 | final class ViewForTest extends BaseMockAddOn
15 | {
16 |     #[ForTestOnly]
17 |    public static function set(ViewInterface $mock): void
18 |    {
19 |        View::replaceWithMock($mock);
20 |    }
21 | 
22 |     /** @inheritDoc */
23 |     #[ForTestOnly]
24 |     #[\Override]
25 |     public static function cancel(): void
26 |     {
27 |         View::replaceWithMock(null);
28 |     }
29 | }
30 | 


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


--------------------------------------------------------------------------------
/Main/Console/Commands/CliLogLevel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Constructor\Data\MainLogLevel;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class CliLogLevel
13 | {
14 |     /**
15 |      * Working with the logging level through the console.
16 |      *
17 |      * Работа с уровнем логирования через консоль.
18 |      */
19 |     public function run(?string $level): string
20 |     {
21 |         if ($level === null) {
22 |             return MainLogLevel::get() . PHP_EOL;
23 |         }
24 | 
25 |         if ($level === 'default') {
26 |             return MainLogLevel::setDefault() . PHP_EOL;
27 |         }
28 | 
29 |         return MainLogLevel::set($level) . PHP_EOL;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/ConfigInfo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class ConfigInfo
11 | {
12 |     /**
13 |      * Returns a list of basic configuration settings, or a setting by name.
14 |      *
15 |      * Возвращает список базовых настроек конфигурации или настройку по названию.
16 |      */
17 |    public function run(array $config, ?string $paramName): false|string
18 |    {
19 |        if ($paramName !== null) {
20 |            $sub = $config['common'][$paramName] ?? null;
21 |            if ($sub !== null) {
22 |                if (\is_bool($sub)) {
23 |                    return ($sub ? '1' : '0') . PHP_EOL;
24 |                }
25 |                if (\is_array($sub)) {
26 |                    return \implode(',', $sub) . PHP_EOL;
27 |                }
28 |                return $sub . PHP_EOL;
29 |            }
30 |            return false;
31 |        }
32 | 
33 |        // Display the complete list.
34 |        // Вывод полного списка.
35 |        $list = [];
36 |        foreach ($config['common'] as $name => $value) {
37 |            if ($name === 'error.reporting') {
38 |                continue;
39 |            }
40 |            if (\is_bool($value)) {
41 |                $value = $value ? 'true' : 'false';
42 |            }
43 |            if (\is_array($value)) {
44 |                continue;
45 |            }
46 |            $list[] = "$name: $value";
47 |        }
48 | 
49 |        return \implode(PHP_EOL, $list) . PHP_EOL;
50 |    }
51 | }
52 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Deployer/LibDeployerFinder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Console\Commands\Deployer;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\Constructor\Data\SystemSettings;
 9 | 
10 | #[Accessible]
11 | final class LibDeployerFinder
12 | {
13 |     /**
14 |      * One easy way to determine if a library can be deployed.
15 |      *
16 |      * Единый простой способ определения, что библиотека может быть развёртываемой.
17 |      */
18 |     public function isExists(string $command): bool
19 |     {
20 |         return (bool)SystemSettings::getRealPath("@vendor/$command/updater.json");
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/CommandDetails/CustomList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands\Features\CommandDetails;
 6 | 
 7 | use Hleb\Helpers\TaskHelper;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class CustomList
13 | {
14 |     /**
15 |      * Returns an array of supported command names.
16 |      *
17 |      * Возвращает массив с поддерживаемыми названиями команд.
18 |      */
19 |     public function get(): array
20 |     {
21 |         $custom = [];
22 |         foreach ((new TaskHelper())->getCommands() as $command) {
23 |             $custom[] = $command['name'];
24 |         }
25 |         return $custom;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/ExecutionSpeed/ExecutionSpeed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands\Features\ExecutionSpeed;
 6 | 
 7 | use Hleb\Main\Console\Commands\Features\FeatureInterface;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class ExecutionSpeed implements FeatureInterface
13 | {
14 |     private const DESCRIPTION = 'Returns the execution time (sec) of an empty console request by the framework.';
15 | 
16 |     /**
17 |      * Returns the execution time of an empty console request.
18 |      *
19 |      * Возвращает время выполнения пустого консольного запроса.
20 |      */
21 |     #[\Override]
22 |     public function run(array $argv): string
23 |     {
24 |         return (string)(\microtime(true) - HLEB_START);
25 |     }
26 | 
27 |     /** @inheritDoc */
28 |     #[\Override]
29 |     public static function getDescription(): string
30 |     {
31 |         return self::DESCRIPTION;
32 |     }
33 | 
34 |     /** @inheritDoc */
35 |     #[\Override]
36 |     public function getCode(): int
37 |     {
38 |         return 0;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/FeatureInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\Console\Commands\Features;
 4 | 
 5 | interface FeatureInterface
 6 | {
 7 |     public function run(array $argv): string|false;
 8 | 
 9 |     /**
10 |      * Returns a brief description of the purpose of the application.
11 |      *
12 |      * Возвращает краткое описание предназначения приложения.
13 |      */
14 |     public static function getDescription(): string;
15 | 
16 |     /**
17 |      * Returns the success code of execution.
18 |      *
19 |      * Возвращает код успешности выполнения.
20 |      */
21 |     public function getCode(): int;
22 | }
23 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/FlatKegling/ExpressionTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\Console\Commands\Features\FlatKegling;
 4 | 
 5 | /**
 6 |  * @internal
 7 |  */
 8 | trait ExpressionTrait
 9 | {
10 |     protected const LOGO = "
11 |     █▀▀ █── █▀▀█ ▀▀█▀▀ 　 █─▄▀ █▀▀ █▀▀▀ █── ─▀─ █▀▀▄ █▀▀▀ 
12 |     █▀▀ █── █▄▄█ ──█── 　 █▀▄ ─█▀▀ █─▀█ █── ▀█▀ █──█ █─▀█ 
13 |     ▀── ▀▀▀ ▀──▀ ──▀── 　 ▀──▀ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀▀▀ ▀──▀ ▀▀▀▀";
14 | }
15 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/FlatKegling/StartData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\Console\Commands\Features\FlatKegling;
 4 | 
 5 | /**
 6 |  * @internal
 7 |  */
 8 | class StartData
 9 | {
10 |     protected const TRACK = [' ', '║', ' ', '|', ' ', '|', ' ', '|', ' ', '║', ' ', ' '];
11 | 
12 |     protected const TARGET = [1 => 5, 2 => 4, 3 => 6, 4 => 3, 5 => 5, 6 => 7, 7 => 2, 8 => 4, 9 => 6, 10 => 8];
13 | 
14 |     protected const POSITION = [1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, 9 => 9, 10 => 10];
15 | 
16 |     protected const DAMAGE = [
17 |         'direct' => ['1' => [], '1.5' => [7], '2' => [7, 4], '2.5' => [7, 4], '3' => [4, 7, 8], '3.5' => [4, 2, 8], '4' => [1, 2, 4, 5, 8], '4.5' => [1, 2, 5, 8], '5' => [1, 2, 3, 5, 8, 9], '5.5' => [1, 3, 5, 9], '6' => [3, 6, 9], '6.5' => [3, 6, 9], '7' => [6, 9, 10], '7.5' => [6, 10], '8' => [6, 10], '8.5' => [10], '9' => []],
18 | 
19 |         'touch' => [1 => [[3, 6, 5, 9], [2, 5, 4, 8]], 2 => [[5, 9], [4, 7]], 3 => [[6, 10], [5, 8]], 4 => [[8], [7]], 5 => [[9], [8]], 6 => [[10], [9]], 7 => [[], []], 8 => [[], []], 9 => [[], []], 10 => [[], []]]
20 |     ];
21 | }
22 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/Features/OriginCommand/OriginCommandReturn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands\Features\OriginCommand;
 6 | 
 7 | use Hleb\Main\Console\Commands\Features\FeatureInterface;
 8 | 
 9 | /**
10 |  * Return the arguments passed with the command.
11 |  *
12 |  * Возвращение аргументов, переданных с командой.
13 |  *
14 |  * @internal
15 |  */
16 | final class OriginCommandReturn implements FeatureInterface
17 | {
18 |     private const DESCRIPTION = 'RETURN_COMMAND_ARGUMENTS';
19 | 
20 |     /**
21 |      * Returns the arguments passed with the command.
22 |      *
23 |      * Возвращает аргументы, переданные с командой.
24 |      */
25 |     #[\Override]
26 |     public function run(array $argv): string
27 |     {
28 |         $argv and \array_shift($argv);
29 |         if (!$argv) {
30 |             return '';
31 |         }
32 |         return \implode(' ', $argv) . PHP_EOL;
33 |     }
34 | 
35 |     /** @inheritDoc */
36 |     #[\Override]
37 |     public static function getDescription(): string
38 |     {
39 |         return self::DESCRIPTION;
40 |     }
41 | 
42 |     /** @inheritDoc */
43 |     #[\Override]
44 |     public function getCode(): int
45 |     {
46 |         return 0;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/FindRouteTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\HlebBootstrap;
 8 | use Hleb\Main\Routes\Search\FindRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | trait FindRouteTrait
14 | {
15 |    public function getBlock(null|string $url, null|string $httpMethod, null|string $domain): bool|string|array
16 |    {
17 |        $method = \strtoupper($httpMethod ?: 'get');
18 |        if (!\in_array($method, HlebBootstrap::HTTP_TYPES)) {
19 |            return 'Error! Incorrect HTTP request method specified. Allowed:' .
20 |                \implode(', ', HlebBootstrap::HTTP_TYPES) . PHP_EOL;
21 |        }
22 |        $handler = (new FindRoute($url));
23 |        $search = $handler->one($method, $domain ?: '');
24 |        if ($handler->isBlocked()) {
25 |            return 'Routes are blocked.' . PHP_EOL;
26 |        }
27 |        $errors = $handler->getError();
28 |        if ($errors) {
29 |            return 'Error! ' . \reset($errors) . PHP_EOL;
30 |        }
31 |        if (\is_array($search)) {
32 |            $search['name'] = $handler->getRouteName();
33 |            $search['params'] = $handler->getData();
34 |        }
35 | 
36 |        return $search;
37 |    }
38 | 
39 |    protected function splitUrl(string $url, ?string $domain): array
40 |    {
41 |        $parse = \parse_url($url);
42 |        $path = $parse['path'] ?? '/';
43 |        $domain = $parse['host'] ?? $domain;
44 | 
45 |        return [$path, $domain];
46 |    }
47 | }
48 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/LatestLogs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Constructor\Data\SystemSettings;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class LatestLogs
13 | {
14 |     /**
15 |      * Returns the latest file log data.
16 |      *
17 |      * Возвращает данные последних файловых логов.
18 |      */
19 |    public function run(null|string $linesArg, null|string $fileArg): string
20 |    {
21 |        $lines = 3;
22 |        $files = 5;
23 |        if ($linesArg !== null) {
24 |            $lines = ((int)$linesArg) ?: $lines;
25 |        }
26 |        if ($fileArg !== null) {
27 |            $files = ((int)$fileArg) ?: $files;
28 |        }
29 |        $dir = SystemSettings::getPath('@storage/logs');
30 |        $logs = [];
31 |        foreach (\glob($dir . '/*') as $log) {
32 |            if (!\is_dir($log) && !\str_ends_with($log, '_mail.log')) {
33 |                $logs[$log] = \filemtime($log);
34 |            }
35 |        }
36 |        \asort($logs);
37 |        $files = \array_slice(\array_keys($logs), -$files, $files);
38 |        if (!$files) {
39 |            return 'Logs not found.' . PHP_EOL;
40 |        }
41 |        $data = [];
42 |        foreach ($files as $file) {
43 |            $data[] = \basename($file) . ':' . PHP_EOL;
44 |            $rows = \array_slice(\file($file) ?: [], -$lines, $lines);
45 |            \array_push($data, ...$rows);
46 |        }
47 |        return \implode(PHP_EOL, $data) . PHP_EOL;
48 |    }
49 | }
50 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/LockProject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Constructor\Data\SystemSettings;
 8 | use Hleb\Static\Log;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class LockProject
14 | {
15 |     /**
16 |      * Blocking / unblocking the work of routes (project).
17 |      *
18 |      * Блокировка/разблокировка работы маршрутов (проекта).
19 |      */
20 |    public function run(bool $status): string
21 |    {
22 |        $dir = SystemSettings::getRealPath('storage');
23 |        $file = $dir . '/cache/routes/lock-status.info';
24 |        \hl_create_directory($file);
25 |        \file_put_contents($file, (int)$status);
26 |        @\chmod($file, 0664);
27 |        $message = $status ? 'PROJECT LOCKED!' : 'Project unlocked.';
28 | 
29 |        Log::info($message);
30 | 
31 |        return $message . PHP_EOL;
32 |    }
33 | }
34 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/RouteCacheUpdater.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Constructor\Actions\UpdateRouteCacheAction;
 8 | use Hleb\CoreException;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class RouteCacheUpdater
14 | {
15 |     private int $code = 0;
16 | 
17 |     /**
18 |      * Returns the code of the executed command or a default value.
19 |      *
20 |      * Возвращает код выполненной команды или значение по умолчанию.
21 |      */
22 |     public function getCode(): int
23 |     {
24 |         return $this->code;
25 |     }
26 | 
27 |     /**
28 |      * Updates the route cache.
29 |      *
30 |      * Обновляет кеш маршрутов.
31 |      */
32 |     public function run(): string
33 |     {
34 |         try {
35 |             try {
36 |                 (new UpdateRouteCacheAction())->run();
37 |             } catch (CoreException) {
38 |                 $this->code = 1;
39 |                 return 'Error! Failed to save route cache. Check the necessary permissions.' . PHP_EOL;
40 |             }
41 |         } catch (\Throwable $e) {
42 |             $this->code = 1;
43 |             return $e->getMessage() . PHP_EOL;
44 |         }
45 |         // Если расширение установлено для CLI
46 |         if (\function_exists('opcache_reset')) {
47 |             \opcache_reset();
48 |         }
49 |         $this->code = 0;
50 |         return 'The route cache has been successfully updated!' . PHP_EOL;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/RouteClearCache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Helpers\DirectoryCleaner;
 8 | use Hleb\Static\Path;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class RouteClearCache
14 | {
15 |     private int $code = 0;
16 | 
17 |     /**
18 |      * Returns the code of the executed command or a default value.
19 |      *
20 |      * Возвращает код выполненной команды или значение по умолчанию.
21 |      */
22 |     public function getCode(): int
23 |     {
24 |         return $this->code;
25 |     }
26 | 
27 |     /**
28 |      * Deletes the route cache.
29 |      *
30 |      * Удаляет кеш маршрутов.
31 |      */
32 |     public function run(): string
33 |     {
34 |         try {
35 |                $cleaner = new DirectoryCleaner();
36 |                $cleaner->forceRemoveDir(Path::get('@storage/cache/routes'));
37 |                if ($cleaner->getErrors()) {
38 |                    $this->code = 1;
39 |                    return 'ERROR:' . implode(PHP_EOL, $cleaner->getErrors()) . PHP_EOL;
40 |                }
41 |         } catch (\Throwable $e) {
42 |             $this->code = 1;
43 |             return $e->getMessage() . PHP_EOL;
44 |         }
45 |         // Если расширение установлено для CLI
46 |         if (\function_exists('opcache_reset')) {
47 |             \opcache_reset();
48 |         }
49 |         $this->code = 0;
50 |         return 'The route cache has been successfully cleared!' . PHP_EOL;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/SearchRoute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\HlebBootstrap;
 8 | use Hleb\Main\Routes\Search\FindRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class SearchRoute
14 | {
15 |     use FindRouteTrait;
16 | 
17 |     private int $code = 0;
18 | 
19 |     /**
20 |      * Returns the code of the executed command or a default value.
21 |      *
22 |      * Возвращает код выполненной команды или значение по умолчанию.
23 |      */
24 |     public function getCode(): int
25 |     {
26 |         return $this->code;
27 |     }
28 | 
29 |     /**
30 |      * Returns a message about the route address that matches the conditions.
31 |      *
32 |      * Возвращает сообщение об адресе маршрута, который соответствует условиям.
33 |      */
34 |    public function run(null|string $url, null|string $httpMethod, null|string $domain): string
35 |    {
36 |        if ($url === null) {
37 |            return 'Error! Required argument `url` not specified: php console --find-route <url> [method] [domain]' . PHP_EOL;
38 |        }
39 | 
40 |        [$url, $domain] = $this->splitUrl($url, $domain);
41 | 
42 |        $block = $this->getBlock($url, $httpMethod, $domain);
43 |        if (\is_string($block)) {
44 |            $this->code = 1;
45 |            return $block;
46 |        }
47 | 
48 |        return ($block ? 'OK' : 'Not found.') . PHP_EOL;
49 |    }
50 | }
51 | 


--------------------------------------------------------------------------------
/Main/Console/Commands/TwigCacheUpdater.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Console\Commands;
 6 | 
 7 | use Hleb\Constructor\Data\SystemSettings;
 8 | use Hleb\Helpers\DirectoryCleaner;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class TwigCacheUpdater
14 | {
15 |     private int $code = 0;
16 | 
17 |     /**
18 |      * Returns the code of the executed command or a default value.
19 |      *
20 |      * Возвращает код выполненной команды или значение по умолчанию.
21 |      */
22 |     public function getCode(): int
23 |     {
24 |         return $this->code;
25 |     }
26 | 
27 |     /**
28 |      * Clears the cache for the Twig templating engine.
29 |      *
30 |      * Очищает кеш для шаблонизатора Twig.
31 |      */
32 |     public function run(): string
33 |     {
34 |         $cleaner = new DirectoryCleaner();
35 |         $cleaner->forceRemoveDir(SystemSettings::getRealPath('storage') . '/cache/twig/compilation');
36 |         $errors = $cleaner->getErrors();
37 |         if ($errors) {
38 |             $this->code = 1;
39 |             return \end($errors) . PHP_EOL;
40 |         }
41 | 
42 |         return 'Successfully cleared the Twig templating cache.' . PHP_EOL;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Main/Console/Extreme/ExtremeRegister.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Console\Extreme;
 6 | 
 7 | /**
 8 |  * Displaying the terminal access form.
 9 |  *
10 |  * Вывод формы доступа к терминалу.
11 |  *
12 |  * @internal
13 |  */
14 | final readonly class ExtremeRegister
15 | {
16 |     public function run(): false
17 |     {
18 |         $uri = ExtremeRequest::getUri();
19 |         $name = ExtremeIdentifier::KEY_NAME;
20 | 
21 |         // You can increase the strength of the key by lengthening it or adding other characters.
22 |         // Вы можете увеличить надёжность ключа, удлинив его или добавив другие символы.
23 |         $keyPath = ExtremeIdentifier::KEY_PATH;
24 | 
25 |         $m = "
26 |        <h2>Web Console</h2><hr>
27 |        <p>A login key has been created in the project file: /" . $keyPath . '</p>';
28 |         $m .= "
29 |         <form name='register' action='$uri' method='post' autocomplete='off'>
30 |            Login key: <input name='$name' type='text' value='' autocomplete='off' minlength='72'><button type='submit'>Send</button>
31 |         </form>";
32 |         echo $m;
33 | 
34 |         return false;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Main/Console/Extreme/ExtremeRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Console\Extreme;
 6 | 
 7 | use JetBrains\PhpStorm\NoReturn;
 8 | 
 9 | /**
10 |  * Contains possible manipulations with the location address of the terminal.
11 |  *
12 |  * Содержит возможные манипуляции с адресом размещения терминала.
13 |  *
14 |  * @internal
15 |  */
16 | final class ExtremeRequest
17 | {
18 |     /** @internal */
19 |    public static function getUri(): string
20 |    {
21 |        $uri = \explode('?', $_SERVER['REQUEST_URI'] ?? '/');
22 |        return \current($uri);
23 |    }
24 | 
25 |     /**
26 |      * @throws \AsyncExitException
27 |      * @internal
28 |      */
29 |    #[NoReturn] public static function redirect(string $uri): void
30 |    {
31 |        \async_exit('', 302, ['Location' => $uri]);
32 |    }
33 | }
34 | 


--------------------------------------------------------------------------------
/Main/Console/WebConsoleOnPage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Console;
 6 | 
 7 | use Hleb\Constructor\Attributes\Accessible;
 8 | use Hleb\CoreException;
 9 | use Hleb\Static\Response;
10 | 
11 | #[Accessible]
12 | final class WebConsoleOnPage extends WebConsole
13 | {
14 |     /**
15 |      * Connects all the necessary methods to place
16 |      * the Web console on the page.
17 |      * You can display the WEB console on a specific
18 |      * page of the site using the following code:
19 |      *
20 |      * Соединяет все необходимые методы для размещения
21 |      * Web-консоли на странице.
22 |      * Отобразить WEB-консоль на определенной странице
23 |      * сайта можно при помощи следующего кода:
24 |      *
25 |      * /routes/map.php:
26 |      * Route::match(['get', 'post'], '/web-console', view('console'));
27 |      *
28 |      * /resources/views/console.php:
29 |      * <?php
30 |      * (new \Hleb\Main\Console\WebConsoleOnPage())->run();
31 |      *
32 |      *
33 |      * @throws CoreException
34 |      */
35 |     public function run(): void
36 |     {
37 |         Response::addHeaders(['Content-Type' => 'text/html; charset=utf-8']);
38 |         ob_start();
39 |         $console = '';
40 |         $result = $this->load();
41 |         $arguments = $this->getArgs();
42 |         $arguments[] = '--strict-verbosity';
43 |         $result and $console = (new ConsoleHandler($arguments))->run();
44 |         $content = ob_get_clean();
45 |         Response::addToBody($content . $this->addFooter($console));
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Main/ErrorTemplates.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main;
 6 | 
 7 | use Hleb\Http401UnauthorizedException;
 8 | use Hleb\Http403ForbiddenException;
 9 | use Hleb\Http404NotFoundException;
10 | 
11 | /**
12 |  * Allows you to display frequently used HTTP error statuses in the form of a designed page.
13 |  *
14 |  * Позволяет выводить часто используемые статусы HTTP-ошибок в виде оформленной страницы.
15 |  *
16 |  * @internal
17 |  */
18 | final readonly class ErrorTemplates
19 | {
20 |     public function __construct(private string|int $template)
21 |     {
22 |     }
23 | 
24 |     public function searchAndThrowError(): void
25 |     {
26 |         $error = match ($this->template) {
27 |             '404', 404 => new Http404NotFoundException(),
28 |             '403', 403 => new Http403ForbiddenException(),
29 |             '401', 401 => new Http401UnauthorizedException(),
30 |             default => null,
31 |         };
32 |         if ($error) {
33 |             throw $error;
34 |         }
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Main/Insert/BaseAsyncSingleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Insert;
 6 | 
 7 | use Hleb\Constructor\Attributes\AvailableAsParent;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * Does not imply getting instance.
12 |  *
13 |  * Не подразумевает получение instance.
14 |  */
15 | #[AvailableAsParent]
16 | abstract class BaseAsyncSingleton
17 | {
18 |     final protected function __construct() {}
19 | 
20 |     final protected function __clone() {}
21 | 
22 |     /** @throws RuntimeException */
23 |     final public function __wakeup(): void
24 |     {
25 |         throw new RuntimeException("Cannot serialize singleton");
26 |     }
27 | 
28 |     final public function __serialize(): array
29 |     {
30 |         self::__wakeup();
31 |     }
32 | 
33 |     final public function __unserialize(array $data)
34 |     {
35 |         self::__wakeup();
36 |     }
37 | 
38 |     /**
39 |      * Sets the default values when the framework initializes the class.
40 |      * Only used for this purpose in asynchronous requests.
41 |      *
42 |      * Выставляет значения по умолчанию при инициализации класса фреймворком.
43 |      * Используется только для этой цели в асинхронных запросах.
44 |      */
45 |     abstract public static function rollback(): void;
46 | 
47 | }
48 | 


--------------------------------------------------------------------------------
/Main/Insert/BaseSingleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Insert;
 6 | 
 7 | use Hleb\Constructor\Attributes\AvailableAsParent;
 8 | use RuntimeException;
 9 | 
10 | #[AvailableAsParent]
11 | class BaseSingleton
12 | {
13 |     private static array $instances = [];
14 | 
15 |     final protected function __construct() {}
16 | 
17 |     final protected function __clone() {}
18 | 
19 |     /**
20 |      * @internal - use ExternalSingleton to get an instance.
21 |      *           - для получения экземпляра используйте ExternalSingleton.
22 |      */
23 |     final protected static function getInstance(): static
24 |     {
25 |         $className = static::class;
26 |         if (!isset(self::$instances[$className])) {
27 |             self::$instances[$className] = new static;
28 |         }
29 |         return self::$instances[$className];
30 |     }
31 | 
32 |     /** @throws RuntimeException */
33 |     final public function __wakeup(): void
34 |     {
35 |         throw new RuntimeException("Cannot serialize singleton");
36 |     }
37 | 
38 |     final public function __serialize(): array
39 |     {
40 |         self::__wakeup();
41 |     }
42 | 
43 |     final public function __unserialize(array $data)
44 |     {
45 |         self::__wakeup();
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Main/Insert/ContainerUniqueItem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Insert;
 6 | 
 7 | use Hleb\Static\DI;
 8 | 
 9 | /**
10 |  *
11 |  * A highly specialized class for standard singleton objects in a container.
12 |  * The peculiarity of inherited classes is that they cannot be cloned.
13 |  * Since this class is used in container singleton object classes,
14 |  * then you can apply it to a class and also prohibit the creation
15 |  * of an object of this class using Creator.
16 |  *
17 |  * Узкоспециальный класс для стандартных объектов-singletons в контейнере.
18 |  * Особенностью унаследованных классов является то, что их нельзя клонировать.
19 |  * Так как этот класс используется в классах объектов-singletons контейнера,
20 |  * то можно применяя его к классу также запретить создание объекта этого класса
21 |  * с помощью Creator.
22 |  *
23 |  * @see DI
24 |  *
25 |  * @internal
26 |  */
27 | class ContainerUniqueItem
28 | {
29 |     final protected function __clone()
30 |     {
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Main/Insert/ExternalSingleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Insert;
 6 | 
 7 | use Hleb\Constructor\Attributes\AvailableAsParent;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * For backward compatibility with custom containers,
12 |  * this class can only be extended.
13 |  *
14 |  * Для обратной совместимостью с пользовательскими контейнерами
15 |  * этот класс может только расширяться.
16 |  */
17 | #[AvailableAsParent]
18 | class ExternalSingleton
19 | {
20 |     private static array $instances = [];
21 | 
22 |     final protected function __construct() {}
23 | 
24 |     final protected function __clone() {}
25 | 
26 |     /**
27 |      * Allows you to get a reference to an instance of a class.
28 |      *
29 |      * Позволяет получить ссылку на экземпляр класса.
30 |      */
31 |     final public static function instance(): static
32 |     {
33 |         $className = static::class;
34 |         if (!isset(self::$instances[$className])) {
35 |             self::$instances[$className] = new static;
36 |         }
37 |         return self::$instances[$className];
38 |     }
39 | 
40 |     /** @throws RuntimeException */
41 |     final public function __wakeup(): void
42 |     {
43 |         throw new RuntimeException("Cannot serialize singleton");
44 |     }
45 | 
46 |     final public function __serialize(): array
47 |     {
48 |         self::__wakeup();
49 |     }
50 | 
51 |     final public function __unserialize(array $data)
52 |     {
53 |         self::__wakeup();
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/Main/Insert/OpenInstanceSingleton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Insert;
 6 | 
 7 | use Hleb\Constructor\Attributes\AvailableAsParent;
 8 | 
 9 | #[AvailableAsParent]
10 | class OpenInstanceSingleton extends BaseSingleton
11 | {
12 |     /**
13 |      * Allows you to get a reference to an instance of a class.
14 |      *
15 |      * Позволяет получить ссылку на экземпляр класса.
16 |      */
17 |     final public static function instance(): static
18 |     {
19 |         return self::getInstance();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Main/Routes/BaseRoute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes;
 6 | 
 7 | use Hleb\Base\RollbackInterface;
 8 | use Hleb\Main\Insert\BaseAsyncSingleton;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class BaseRoute extends BaseAsyncSingleton  implements RollbackInterface
14 | {
15 | 
16 |     private static array $data = [];
17 | 
18 |     /**
19 |      * @inheritDoc
20 |      *
21 |      * @internal
22 |      */
23 |     #[\Override]
24 |     public static function rollback(): void
25 |     {
26 |         self::$data = [];
27 |     }
28 | 
29 |     /**
30 |      * @internal
31 |      */
32 |     public static function completion(): array
33 |     {
34 |         $data = self::$data;
35 |         self::$data = [];
36 | 
37 |         return $data;
38 |     }
39 | 
40 |     /**
41 |      * @internal
42 |      */
43 |     public static function add(array $method): void
44 |     {
45 |         self::$data[] = $method;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/BaseType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods;
 6 | 
 7 | use Hleb\Constructor\Data\View;
 8 | use Hleb\Main\Routes\Methods\Traits\StandardTrait;
 9 | use Hleb\Main\Routes\StandardRoute;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | abstract class BaseType extends StandardRoute
15 | {
16 |     use StandardTrait;
17 | 
18 |     public function __construct(string $route, null|int|float|string|View $view = null)
19 |     {
20 |         $params = null;
21 |         if ($view instanceof View) {
22 |             $params = $view->toArray();
23 |         } else if ($view !== null) {
24 |             $params = (string)$view;
25 |         }
26 |         $types = \array_unique(\array_map('strtoupper', $this->types()));
27 | 
28 |         $route = $this->updateRouteAddress($route);
29 | 
30 |         $default = $this->getDefaultValues($route);
31 | 
32 |         $data = [
33 |             'route' => $route,
34 |             'view' => $params,
35 |         ];
36 | 
37 |         if ($default) {
38 |             $data['default'] = $default;
39 |         }
40 | 
41 |         $this->register([
42 |             'method' => self::ADD_TYPE,
43 |             'name' => $this->methodName(),
44 |             'types' => $types,
45 |             'data' => $data,
46 |         ]);
47 |     }
48 | 
49 |     abstract protected function types(): array;
50 | 
51 |     abstract protected function methodName(): string;
52 | }
53 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupAfterTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupAfter;
 9 | 
10 | trait GroupAfterTrait
11 | {
12 |     /**
13 |      * Execute a subsequent controller that will be executed
14 |      * after the route's main controller(action).
15 |      * The class method can be specified via '@', for example,
16 |      * 'App\Middleware\DefaultMiddlewareAfter@{method}'.
17 |      * If it is not specified, 'index' will be used.
18 |      * $target can be set to App\Middleware\DefaultMiddlewareAfter::class,
19 |      * then the controller method must be specified in the $method argument.
20 |      *
21 |      * Выполнение последующего контроллера, который будет выполнен
22 |      * после основного контроллера(действия) маршрута.
23 |      * Указать метод класса можно через '@', например,
24 |      * 'App\Middleware\DefaultMiddlewareAfter@{method}'.
25 |      * Если не указан, будет использован 'index'.
26 |      * В $target можно указать App\Middleware\DefaultMiddlewareAfter::class,
27 |      * тогда в аргументе $method должен быть указан метод контроллера.
28 |      *
29 |      * ```php
30 |      *   Route::toGroup()->after(DefaultMiddlewareAfter::class);
31 |      *      // ... //
32 |      *   Route::endGroup();
33 |      *  ```
34 |      */
35 |     public function after(string $target, ?string $method = null, array $data = []):  GroupAfter
36 |     {
37 |         return new GroupAfter($target, $method, $data);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupBeforeTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupMiddleware;
 9 | 
10 | trait GroupBeforeTrait
11 | {
12 |     /**
13 |      * Execution of the pre-controller.
14 |      * The class method can be specified via '@', for example,
15 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Middleware\DefaultMiddlewareBefore::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      * An alias for the middleware() method.
20 |      *
21 |      * Выполнение предварительного контроллера.
22 |      * Указать метод класса можно через '@', например,
23 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
24 |      * Если не указан, будет использован 'index'.
25 |      * В $target можно указать App\Middleware\DefaultMiddlewareBefore::class,
26 |      * тогда в аргументе $method должен быть указан метод контроллера.
27 |      * Псевдоним метода middleware().
28 |      *
29 |      * ```php
30 |      *  Route::toGroup()->before(DefaultMiddleware::class);
31 |      *     // ... //
32 |      *  Route::endGroup();
33 |      * ```
34 |      */
35 |     public function before(string $target, ?string $method = null, array $data = []):  GroupMiddleware
36 |     {
37 |         return new GroupMiddleware($target, $method, $data);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupMiddlewareTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupMiddleware;
 9 | 
10 | trait GroupMiddlewareTrait
11 | {
12 |     /**
13 |      * Execution of the pre-controller.
14 |      * The class method can be specified via '@', for example,
15 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Middleware\DefaultMiddlewareBefore::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      *
20 |      * Выполнение предварительного контроллера.
21 |      * Указать метод класса можно через '@', например,
22 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
23 |      * Если не указан, будет использован 'index'.
24 |      * В $target можно указать App\Middleware\DefaultMiddlewareBefore::class,
25 |      * тогда в аргументе $method должен быть указан метод контроллера.
26 |      *
27 |      * ```php
28 |      *  Route::toGroup()->middleware(DefaultMiddleware::class);
29 |      *    // ... //
30 |      *  Route::endGroup();
31 |      * ```
32 |      */
33 |     public function middleware(string $target, ?string $method = null, array $data = []):  GroupMiddleware
34 |     {
35 |         return new GroupMiddleware($target, $method, $data);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupNoDebugTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupNoDebug;
 9 | 
10 | trait GroupNoDebugTrait
11 | {
12 |     /**
13 |      * Disables the debug panel output for group routes.
14 |      * Only relevant in DEBUG mode.
15 |      * The implication is that this is not a workaround, and under these conditions
16 |      * there is really no need to display a debug panel, such as a GET request
17 |      * to an API expecting a JSON response.
18 |      *
19 |      * Отключает вывод отладочной панели у маршрутов группы.
20 |      * Актуально только в DEBUG-режиме.
21 |      * Подразумевается, что это не временное решение, а в этих условиях действительно
22 |      * не нужно выводить панель отладки, например, GET-запрос к API, ожидающий в ответ JSON.
23 |      *
24 |      * ```php
25 |      *  Route::toGroup()->noDebug();
26 |      *    // ... //
27 |      *  Route::endGroup();
28 |      * ```
29 |      */
30 |     public function noDebug(): GroupNoDebug
31 |     {
32 |         return new GroupNoDebug();
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupPlainTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupPlain;
 9 | 
10 | trait GroupPlainTrait
11 | {
12 |     /**
13 |      * Indicates loading optimization for simple text or HTML
14 |      * pages that do not require sessions or anything else.
15 |      * Applies the action to routes in the group.
16 |      * If present, overrides the 'session.enabled' value
17 |      * in the framework configuration.
18 |      * (!) A positive value disables session initialization
19 |      * and Cookies when accessing routes in a group.
20 |      *
21 |      * Указывает на оптимизацию загрузки для простых текстовых
22 |      * или HTML страниц не требующих сессий и прочего.
23 |      * Применяет действие к маршрутам в группе.
24 |      * При наличии переопределяет значение 'session.enabled'
25 |      * в конфигурации фреймворка.
26 |      * (!) Положительное значение отключает инициализацию сессий
27 |      * и Cookies при обращении к маршрутам в группе.
28 |      *
29 |      * ```php
30 |      *  Route::toGroup()->plain();
31 |      *     // ... //
32 |      *  Route::endGroup();
33 |      *```
34 |      *
35 |      * @param bool $on - simplification mode active.
36 |      *
37 |      *                 - активность режима упрощения.
38 |      */
39 |     public function plain(bool $on = true): GroupPlain
40 |     {
41 |         return new GroupPlain($on);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupPrefixTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupPrefix;
 9 | 
10 | trait GroupPrefixTrait
11 | {
12 |     /**
13 |      * Set a prefix for a route group.
14 |      * For example, for the prefix '/test/', if the group contains the route '/page/',
15 |      * the address '/test/page/' for that route will be checked.
16 |      *
17 |      * Установка префикса к группе маршрутов.
18 |      * Например, для префикса '/test/', если в группе находится маршрут '/page/',
19 |      * будет проверяться адрес '/test/page/' для этого маршрута.
20 |      *
21 |      * ```php
22 |      *  Route::toGroup()->prefix('/test/');
23 |      *    // ... //
24 |      *  Route::endGroup();
25 |      * ```
26 |      */
27 |     public function prefix(string $prefix): GroupPrefix
28 |     {
29 |         return new GroupPrefix($prefix);
30 | 
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupProtectTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | 
 8 | use Hleb\Route\Group\GroupProtect;
 9 | 
10 | trait GroupProtectTrait
11 | {
12 |     /**
13 |      * Applies the specified route protection to subsequent methods in the group.
14 |      *
15 |      * Применяет указанную защиту маршрута к последующим методам в группе.
16 |      *
17 |      * ```php
18 |      *  Route::toGroup()->protect();
19 |      *       // ... //
20 |      *  Route::endGroup();
21 |      * ```
22 |      */
23 |     public function protect(string|array $rules = 'CSRF'): GroupProtect
24 |     {
25 |         return new GroupProtect($rules);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | use Hleb\Route\Group\EndGroup;
 8 | use Route;
 9 | 
10 | trait GroupTrait
11 | {
12 |     /**
13 |      * Allows you to use group assignments within a function.
14 |      *
15 |      * Позволяет использовать назначение групп внутри функции.
16 |      *
17 |      * ```php
18 |      * Route::toGroup()
19 |      *     ->prefix('example')
20 |      *     ->group(function () {
21 |      *        Route::get('/first/', '1st');
22 |      *        Route::get('/second/', '2nd');
23 |      *     });
24 |      *
25 |      * ```
26 |      */
27 |     public function group(callable $fn): EndGroup
28 |     {
29 |         $fn();
30 | 
31 |         return new EndGroup();
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/GroupWhereTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 6 | 
 7 | use Hleb\Route\Group\GroupWhere;
 8 | 
 9 | trait GroupWhereTrait
10 | {
11 |     /**
12 |      * Checking the dynamic parts of a route in a group
13 |      * using a regular expression.
14 |      *
15 |      * Проверка динамических частей маршрута в группе
16 |      * при помощи регулярного выражения.
17 |      *
18 |      * ```php
19 |      *   Route::toGroup()->prefix('/order/{id}')->where(['id' => '[0-9]+']);
20 |      *        // ... //
21 |      *   Route::endGroup();
22 |      * ```
23 |      */
24 |     public function where(array $rules): GroupWhere
25 |     {
26 |         return new GroupWhere($rules);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/Group/StandardGroupTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\Routes\Methods\Traits\Group;
 4 | 
 5 | trait StandardGroupTrait
 6 | {
 7 |     use GroupPrefixTrait;
 8 |     use GroupMiddlewareTrait;
 9 |     use GroupAfterTrait;
10 |     use GroupBeforeTrait;
11 |     use GroupDomainTrait;
12 |     use GroupWhereTrait;
13 |     use GroupNoDebugTrait;
14 |     use GroupTrait;
15 | }
16 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertAfterTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\After;
 9 | 
10 | trait InsertAfterTrait
11 | {
12 |     /**
13 |      * Execute a subsequent controller that will be executed
14 |      * after the route's main controller(action).
15 |      * The class method can be specified via '@', for example,
16 |      * 'App\Middleware\DefaultMiddlewareAfter@{method}'.
17 |      * If it is not specified, 'index' will be used.
18 |      * $target can be set to App\Middleware\DefaultMiddlewareAfter::class,
19 |      * then the controller method must be specified in the $method argument.
20 |      *
21 |      * Выполнение последующего контроллера, который будет выполнен
22 |      * после основного контроллера(действия) маршрута.
23 |      * Указать метод класса можно через '@', например,
24 |      * 'App\Middleware\DefaultMiddlewareAfter@{method}'.
25 |      * Если не указан, будет использован 'index'.
26 |      * В $target можно указать App\Middleware\DefaultMiddlewareAfter::class,
27 |      * тогда в аргументе $method должен быть указан метод контроллера.
28 |      *
29 |      * ```php
30 |      *  Route::get('/example/', view('example'))->after(After::class);
31 |      * ```
32 |      */
33 |     public function after(string $target, ?string $method = null, array $data = []): After
34 |     {
35 |         return new After($target, $method, $data);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertBeforeTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Middleware;
 9 | 
10 | trait InsertBeforeTrait
11 | {
12 |     /**
13 |      * Execution of the pre-controller.
14 |      * The class method can be specified via '@', for example,
15 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Middleware\DefaultMiddlewareBefore::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      * An alias for the middleware() method.
20 |      *
21 |      * Выполнение предварительного контроллера.
22 |      * Указать метод класса можно через '@', например,
23 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
24 |      * Если не указан, будет использован 'index'.
25 |      * В $target можно указать App\Middleware\DefaultMiddlewareBefore::class,
26 |      * тогда в аргументе $method должен быть указан метод контроллера.
27 |      * Псевдоним метода middleware().
28 |      *
29 |      * ```php
30 |      *   Route::get('/example/', view('example'))->before(Before::class);
31 |      * ```
32 |      */
33 |     public function before(string $target, ?string $method = null, array $data = []): Middleware
34 |     {
35 |         return new Middleware($target, $method, $data);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertControllerTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Controller;
 9 | 
10 | trait InsertControllerTrait
11 | {
12 |     /**
13 |      * Assignment of the controller.
14 |      * The class method can be specified via '@', for example,
15 |      * 'App\Controllers\DefaultController@{method}'
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Controllers\DefaultController::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      *
20 |      * Назначение контроллера.
21 |      * Указать метод класса можно через '@', например,
22 |      * 'App\Controllers\DefaultController@{method}'.
23 |      * Если не указан, будет использован 'index'.
24 |      * В $target можно указать App\Controllers\DefaultController::class,
25 |      * тогда в аргументе $method должен быть указан метод контроллера.
26 |      *
27 |      * ```php
28 |      *   Route::get('/user/')->controller(UserController::class);
29 |      * ```
30 |      */
31 |     public function controller(string $target, ?string $method = null): Controller
32 |     {
33 |         return new Controller($target, $method);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertMiddlewareTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Middleware;
 9 | 
10 | trait InsertMiddlewareTrait
11 | {
12 |     /**
13 |      * Execution of the pre-controller.
14 |      * The class method can be specified via '@', for example,
15 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}'.
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Middleware\DefaultMiddlewareBefore::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      *
20 |      * Выполнение предварительного контроллера.
21 |      * Указать метод класса можно через '@', например,
22 |      * 'App\Middleware\DefaultMiddlewareBefore@{method}.
23 |      * Если не указан, будет использован 'index'.
24 |      * В $target можно указать App\Middleware\DefaultMiddlewareBefore::class,
25 |      * тогда в аргументе $method должен быть указан метод контроллера.
26 |      *
27 |      * ```php
28 |      *  Route::get('/', view('home'))->middleware(DefaultMiddleware::class);
29 |      * ```
30 |      */
31 |     public function middleware(string $target, ?string $method = null, array $data = []): Middleware
32 |     {
33 |         return new Middleware($target, $method, $data);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertNameTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Name;
 9 | 
10 | trait InsertNameTrait
11 | {
12 |     /**
13 |      * Defines the name of the route.
14 |      *
15 |      * Задаёт имя маршрута.
16 |      *
17 |      * ```php
18 |      *   Route::get('/', view('default'))->name('homepage');
19 |      * ```
20 |      */
21 |     public function name(string $name): Name
22 |     {
23 |         return new Name($name);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertNoDebugTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | use Hleb\Route\NoDebug;
 8 | 
 9 | trait InsertNoDebugTrait
10 | {
11 |     /**
12 |      * Applies the specified protection to the route.
13 |      * Only relevant in DEBUG mode.
14 |      * The implication is that this is not a workaround, and under these conditions
15 |      * there is really no need to display a debug panel, such as a GET request
16 |      * to an API expecting a JSON response.
17 |      *
18 |      * Отключает вывод отладочной панели у маршрута.
19 |      * Актуально только в DEBUG-режиме.
20 |      * Подразумевается, что это не временное решение, а в этих условиях действительно
21 |      * не нужно выводить панель отладки, например, GET-запрос к API, ожидающий в ответ JSON.
22 |      *
23 |      * ```php
24 |      *    Route::get('/site/healthcheck', 'OK')->noDebug();
25 |      * ```
26 |      */
27 |     public function noDebug(): NoDebug
28 |     {
29 |         return new NoDebug();
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertPageTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | use Hleb\Route\Page;
 8 | 
 9 | trait InsertPageTrait
10 | {
11 |     /**
12 |      * The purpose of a 'page', which is a controller that has HTML resources
13 |      * added before and after it, making it a full-fledged page of a certain type.
14 |      * The class method can be specified via '@', for example,
15 |      * `App\Controllers\DefaultController@{method}`
16 |      * If it is not specified, 'index' will be used.
17 |      * $target can be set to App\Controllers\DefaultController::class,
18 |      * then the controller method must be specified in the $method argument.
19 |      *
20 |      * Назначение 'страницы', представляющей из себя контроллер, к которому добавлены
21 |      * ресурсы HTML до и после, делающие его полноценной страницей определенного типа.
22 |      * Указать метод класса можно через '@', например,
23 |      * 'App\Controllers\DefaultController@{method}'.
24 |      * Если не указан, будет использован 'index'.
25 |      * В $target можно указать App\Controllers\DefaultController::class,
26 |      * тогда в аргументе $method должен быть указан метод контроллера.
27 |      */
28 |     public function page(string $type, string $target, ?string $method = null): Page
29 |     {
30 |         return new Page($type, $target, $method);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertPlainTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Plain;
 9 | 
10 | trait InsertPlainTrait
11 | {
12 |     /**
13 |      * Indicates loading optimization for simple text or HTML
14 |      * pages that do not require sessions or anything else.
15 |      * Applies an action to a route.
16 |      * If present, overrides the 'session.enabled' value
17 |      * in the framework configuration.
18 |      * (!) A positive value disables the initialization
19 |      * of sessions and Cookies when accessing a route.
20 |      *
21 |      * Указывает на оптимизацию загрузки для простых текстовых
22 |      * или HTML страниц не требующих сессий и прочего.
23 |      * Применяет действие к маршруту.
24 |      * При наличии переопределяет значение 'session.enabled'
25 |      * в конфигурации фреймворка.
26 |      * (!) Положительное значение отключает инициализацию сессий
27 |      * и Cookies при обращении к маршруту.
28 |      *
29 |      * ```php
30 |      *     Route::any('/site/info', view('info'))->plain();
31 |      *  ```
32 |      *
33 |      * @param bool $on - simplification mode active.
34 |      *
35 |      *                 - активность режима упрощения.
36 |      */
37 |     public function plain(bool $on = true): Plain
38 |     {
39 |         return new Plain($on);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertProtectTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Protect;
 9 | 
10 | trait InsertProtectTrait
11 | {
12 |     /**
13 |      * Applies the specified protection to the route.
14 |      *
15 |      * Применяет указанную защиту к маршруту.
16 |      *
17 |      * ```php
18 |      *   Route::post('/add/user')
19 |      *      ->controller(UserController::class, 'add')
20 |      *      ->protect();
21 |      * ``
22 |      */
23 |     public function protect(string|array $rules = 'CSRF'): Protect
24 |     {
25 |         return new Protect($rules);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertRedirectTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | use Hleb\Route\Redirect;
 8 | 
 9 | trait InsertRedirectTrait
10 | {
11 |     /**
12 |      * Route-level redirection, when added,
13 |      * all matches to the rules of a given route will be redirected.
14 |      * Cannot be used with one of the controller types or the after() method.
15 |      * The $location value must be the same as implied in the Location HTTP header.
16 |      * Dynamic route parameters can be inserted into the target address.
17 |      * For example:
18 |      *
19 |      * Перенаправление на уровне маршрута, при добавлении
20 |      * все совпадения с правилами данного маршрута будут перенаправлены.
21 |      * Не может быть использовано вместе с одним из типов контроллеров или методом after().
22 |      * Значение $location должно быть аналогичным как подразумевается в HTTP-заголовке Location.
23 |      * Динамические параметры маршрута могут быть вставлены в целевой адрес.
24 |      * Например:
25 |      *
26 |      * ```php
27 |      *  Route::get('/old/address/{name}')->redirect('/new/address/{%name%}', 301);
28 |      * ```
29 |      */
30 |     public function redirect(string $location, int $status = 302): Redirect
31 |     {
32 |         return new Redirect($location, $status);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/InsertWhereTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Methods\Traits;
 6 | 
 7 | 
 8 | use Hleb\Route\Where;
 9 | 
10 | trait InsertWhereTrait
11 | {
12 |     /**
13 |      * When added after get(), post(), etc. methods, sets up regular expression
14 |      * checking of dynamic parts of the route.
15 |      *
16 |      * При добавлении после методов get(), post() и т.д. устанавливает проверку
17 |      * динамических частей маршрута с помощью регулярных выражений.
18 |      *
19 |      * ```php
20 |      * Route::get('/ru/{version}/{page}/', 'Content')
21 |      *     ->where(['version' => '[a-z0-9]+', 'page' => '[a-z]+']);
22 |      * ```
23 |      */
24 |     public function where(array $rules): Where
25 |     {
26 |         return new Where($rules);
27 | 
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Main/Routes/Methods/Traits/StandardTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\Routes\Methods\Traits;
 4 | 
 5 | trait StandardTrait
 6 | {
 7 |     use InsertWhereTrait;
 8 |     use InsertControllerTrait;
 9 |     use InsertMiddlewareTrait;
10 |     use InsertAfterTrait;
11 |     use InsertBeforeTrait;
12 |     use InsertProtectTrait;
13 |     use InsertNameTrait;
14 |     use InsertModuleTrait;
15 |     use InsertDomainTrait;
16 |     use InsertPageTrait;
17 |     use InsertPlainTrait;
18 |     use InsertRedirectTrait;
19 |     use InsertNoDebugTrait;
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/Main/Routes/Prepare/Defender.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Main\Routes\Prepare;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | class Defender
11 | {
12 |     /**
13 |      * So that the output to the cache does not break due to invalid characters,
14 |      * the final data must be processed.
15 |      *
16 |      * Чтобы вывод в кеш не поломался из-за недопустимых символов,
17 |      * конечные данные необходимо обработать.
18 |      */
19 |     public function handle(array &$data): void
20 |     {
21 |         \array_walk_recursive($data, static function (&$value) {
22 |             if (\is_string($value)) {
23 |                 if (\str_contains($value, "'") || \str_ends_with($value, '\\')) {
24 |                     $value = \addcslashes($value, "'\\");
25 |                 }
26 |             }
27 |         });
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Main/Routes/Search/RouteAnyFileManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Routes\Search;
 6 | 
 7 | class RouteAnyFileManager extends RouteFileManager
 8 | {
 9 | 
10 |     /**
11 |      * Request a block for an arbitrary request while saving the state of the current request.
12 |      *
13 |      * Запрос блока для произвольного запроса с сохранением состояния текущего запроса.
14 |      *
15 |      * @inheritDoc
16 |      *
17 |      * @internal
18 |      */
19 |     public function getBlock(): false|array
20 |     {
21 |         $infoCacheDuplicate = self::$infoCache;
22 |         $stubDataDuplicate = self::$stubData;
23 |         $result = parent::getBlock();
24 |         self::$infoCache = $infoCacheDuplicate;
25 |         self::$stubData = $stubDataDuplicate;
26 | 
27 |         return $result;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Main/Routes/Search/RouteAsyncFileManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Main\Routes\Search;
 6 | 
 7 | class RouteAsyncFileManager extends RouteFileManager
 8 | {
 9 |     /**
10 |      * @inheritDoc
11 |      */
12 |     public function getBlock(): false|array
13 |     {
14 |         if (self::$infoCache === null) {
15 |             return parent::getBlock();
16 |         }
17 |         /** @see hl_check() - getBlock async start */
18 |         $this->init();
19 | 
20 |         if (self::$stubData) {
21 |             $this->isBlocked = true;
22 |             return \is_array(self::$stubData) ? self::$stubData : false;
23 |         }
24 |         return parent::searchBlock();
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Main/System/LibraryServiceAddress.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Main\System;
 4 | 
 5 | use Hleb\Constructor\Data\DynamicParams;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class LibraryServiceAddress
11 | {
12 |     final public const KEY = 'hlresource';
13 | 
14 |     /**
15 |      * Returns the full path to the library resource.
16 |      *
17 |      * Возвращает полный путь до ресурса библиотеки.
18 |      */
19 |     public static function getFullAddress(string $library, string $version = 'v1'): string
20 |     {
21 |         $uri = DynamicParams::getRequest()->getUri();
22 |         return $uri->getScheme() . '://' . $uri->getHost() . self::getAddress($library, $version);
23 |     }
24 | 
25 |     /**
26 |      * Returns the path to the library resource.
27 |      *
28 |      * Возвращает путь до ресурса библиотеки.
29 |      */
30 |     public static function getAddress(string $library, string $version = 'v1'): string
31 |     {
32 |         return '/' . self::KEY . '/' . $library . '/' . $version;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Optional/Modules/example/config/main.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | if (\file_exists(__DIR__ . '/main-local.php')) { return (require __DIR__ . '/main-local.php');}
 4 | 
 5 | /**
 6 |  * Custom module settings that override settings from /config/main.php.
 7 |  * Configuration files other than `main` and `database` are not overridden.
 8 |  *
 9 |  * Пользовательские настройки модуля, которые переопределяют настройки из /config/main.php.
10 |  * Другие файлы конфигурации, кроме `main` и `database`, не переопределяются.
11 |  */
12 | return [];
13 | 


--------------------------------------------------------------------------------
/Optional/Modules/example/controllers/DefaultModuleController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace modules_template\module_class_name_template\Controllers;
 4 | 
 5 | use Hleb\Base\Module;
 6 | use Hleb\Constructor\Data\View;
 7 | 
 8 | /**
 9 |  * Template for module controller.
10 |  * You can assign it to a route like this:
11 |  *
12 |  * Шаблон для контроллера модуля.
13 |  * Назначить его в маршруте можно следующим образом:
14 |  *
15 |  * ```php
16 |  * use Modules\Admin\Controllers\DefaultModuleController;
17 |  *
18 |  * Route::get(...)->module('module_base_name_template', DefaultModuleController::class);
19 |  * ```
20 |  */
21 | class DefaultModuleController extends Module
22 | {
23 |     public function index(): View
24 |     {
25 |         /*
26 |          * An example of using the template
27 |          * (to be included from the /views/ folder of the current module).
28 |          *
29 |          * Пример использования шаблона
30 |          * (будет загружен из папки /views/ текущего модуля).
31 |          */
32 |         return view("example");
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Optional/Modules/example/views/example.php:
--------------------------------------------------------------------------------
1 | <?php
2 | /** @var App\Bootstrap\ContainerInterface $container */
3 | 
4 | echo "Module <b>`{$container->settings()->getModuleName()}`</b> template.";
5 | 


--------------------------------------------------------------------------------
/Optional/Templates/controller_class_template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace controller_namespace_template;
 4 | 
 5 | use Hleb\Base\Controller;
 6 | 
 7 | class controller_class_template extends Controller
 8 | {
 9 |     /**
10 |      * controller_description_template
11 |      */
12 |     public function index()
13 |     {
14 |         // Your code here.
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Optional/Templates/middleware_class_template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace middleware_namespace_template;
 4 | 
 5 | use Hleb\Base\Middleware;
 6 | 
 7 | class middleware_class_template extends Middleware
 8 | {
 9 |     /**
10 |      * middleware_description_template
11 |      */
12 |     public function index()
13 |     {
14 |         // Your code here.
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Optional/Templates/model_class_template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace model_namespace_template;
 4 | 
 5 | use Hleb\Base\Model;
 6 | 
 7 | class model_class_template extends Model
 8 | {
 9 |     /**
10 |      * model_description_template
11 |      */
12 |     public static function get()
13 |     {
14 |         // Your code here.
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Optional/Templates/task_class_template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace task_namespace_template;
 4 | 
 5 | use Hleb\Base\Task;
 6 | 
 7 | class task_class_template extends Task
 8 | {
 9 |     #[\Override]
10 |     protected function rules(): array
11 |     {
12 |         return [];
13 |     }
14 |     /**
15 |      * task_description_template
16 |      */
17 |     protected function run(?string $arg = null)
18 |     {
19 |         // Your code here.
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Reference/CommandInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | use Hleb\Base\Task;
 6 | 
 7 | interface CommandInterface
 8 | {
 9 |     /**
10 |      * Execute an initiated command object with arguments.
11 |      *
12 |      * Выполнение инициированного объекта команды с аргументами.
13 |      */
14 |     public function execute(Task $task, array $arguments): mixed;
15 | }
16 | 


--------------------------------------------------------------------------------
/Reference/CommandReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Reference;
 6 | 
 7 | use Hleb\Base\Task;
 8 | use Hleb\Constructor\Attributes\Accessible;
 9 | use Hleb\Constructor\Attributes\AvailableAsParent;
10 | 
11 | /**
12 |  * Caching data of various types in the framework.
13 |  *
14 |  * Кеширование данных различного типа во фреймворке.
15 |  */
16 | #[Accessible] #[AvailableAsParent]
17 | class CommandReference implements CommandInterface, Interface\Command
18 | {
19 |     /**
20 |      * @inheritDoc
21 |      */
22 |     #[\Override]
23 |     public function execute(Task $task, array $arguments = []): mixed
24 |     {
25 |         $task->call($arguments);
26 | 
27 |         return $task->getExecResult();
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Reference/ConverterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | use Phphleb\PsrAdapter\Psr11\IntermediateContainerInterface;
 6 | use Psr\Container\ContainerInterface;
 7 | use Psr\Log\LoggerInterface;
 8 | 
 9 | interface ConverterInterface
10 | {
11 |     /**
12 |      * Returns a wrapper around the logger in a framework based on the PSR-3 interface.
13 |      *
14 |      * Возвращает обертку над механизмом логирования во фреймворке на основе PSR-3 интерфейса.
15 |      */
16 |     public function toPsr3Logger(): LoggerInterface;
17 | 
18 |     /**
19 |      * Wrapper for container implementation according to RPS-11 rules.
20 |      *
21 |      * Обёртка для реализации контейнера по правилам PSR-11.
22 |      *
23 |      * @return IntermediateContainerInterface
24 |      */
25 |     public function toPsr11Container(): ContainerInterface;
26 | 
27 |     /**
28 |      * Returns a wrapper over an object for caching in a framework based on the PSR-16 interface.
29 |      *
30 |      * Возвращает обертку над объектом для кеширования во фреймворке на основе PSR-16 интерфейса.
31 |      */
32 |     public function toPsr16SimpleCache(): \Psr\SimpleCache\CacheInterface;
33 | }
34 | 


--------------------------------------------------------------------------------
/Reference/CsrfInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | interface CsrfInterface
 6 | {
 7 |     /**
 8 |      * The token() method returns the protected token for protection against CSRF attacks.
 9 |      *
10 |      * Метод token() возвращает защищённый токен для защиты от CSRF-атак.
11 |      */
12 |     public function token(): string;
13 | 
14 |     /**
15 |      * The field() method returns HTML content to be inserted
16 |      * into the form to protect against CSRF attacks.
17 |      *
18 |      * Метод field() возвращает HTML-контент для вставки
19 |      * в форму для защиты от CSRF-атак.
20 |      */
21 |     public function field(): string;
22 | 
23 | 
24 |     /**
25 |      * The framework checks the token for protection against CSRF.
26 |      *
27 |      * Проверка фреймворком токена для защиты от CSRF.
28 |      */
29 |     public function validate(?string $key): bool;
30 | 
31 | 
32 |     /**
33 |      * Returns the found token in the request data or null.
34 |      *
35 |      * Возвращает найденный токен в данных запроса или null.
36 |      */
37 |     public function discover(): string|null;
38 | }
39 | 


--------------------------------------------------------------------------------
/Reference/CsrfReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Reference;
 6 | 
 7 | use Hleb\Base\RollbackInterface;
 8 | use Hleb\Constructor\Attributes\Accessible;
 9 | use Hleb\Constructor\Attributes\AvailableAsParent;
10 | use Hleb\Main\Insert\ContainerUniqueItem;
11 | 
12 | #[Accessible] #[AvailableAsParent]
13 | class CsrfReference extends ContainerUniqueItem implements CsrfInterface, Interface\Csrf, RollbackInterface
14 | {
15 |     /**
16 |      * @inheritDoc
17 |      */
18 |     #[\Override]
19 |     public function token(): string
20 |     {
21 |         return \Hleb\Constructor\Protected\Csrf::key();
22 |     }
23 | 
24 |     /**
25 |      * @inheritDoc
26 |      */
27 |     #[\Override]
28 |     public function field(): string
29 |     {
30 |         return '<input type="hidden" name="_token" value="' . $this->token() . '">';
31 |     }
32 | 
33 |     /**
34 |      * @inheritDoc
35 |      */
36 |     #[\Override]
37 |     public function validate(?string $key): bool
38 |     {
39 |         return \Hleb\Constructor\Protected\Csrf::validate($key);
40 |     }
41 | 
42 |     /**
43 |      * @inheritDoc
44 |      */
45 |     #[\Override]
46 |     public function discover(): string|null
47 |     {
48 |         return \Hleb\Constructor\Protected\Csrf::discover();
49 |     }
50 | 
51 |     /**
52 |      * @inheritDoc
53 |      */
54 |     #[\Override]
55 |     public static function rollback(): void
56 |     {
57 |         \Hleb\Constructor\Protected\Csrf::rollback();
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/Reference/DebugInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | /**
 6 |  * For backward compatibility with custom containers,
 7 |  * this interface can only be extended.
 8 |  *
 9 |  * Для обратной совместимостью с пользовательскими контейнерами
10 |  * этот интерфейс может только расширяться.
11 |  */
12 | interface DebugInterface
13 | {
14 |     /**
15 |      * Sends data for storage when debug mode is active.
16 |      * By default, the data is displayed in the framework debug panel.
17 |      *
18 |      * При активном отладочном режиме отправляет данные для хранения.
19 |      * По умолчанию данные выводятся в панель отладки фреймворка.
20 |      */
21 |     public function send(mixed $data, ?string $name = null): void;
22 | 
23 |     /**
24 |      * When debug mode is active, returns any previously added debugging data.
25 |      *
26 |      * При активном режиме отладки возвращает все добавленные ранее отладочные данные.
27 |      */
28 |     public function getCollection(): array;
29 | 
30 |     /**
31 |      * Saves the system tag to debug data.
32 |      *
33 |      * Сохраняет системную метку в отладочные данные.
34 |      *
35 |      * @see hl_check()
36 |      */
37 |     public function setHlCheck(string $message, ?string $file = null, ?int $line = null): void;
38 | 
39 |     /**
40 |      * Returns the status of the debug mode activity.
41 |      *
42 |      * Возвращает статус активности режима отладки.
43 |      */
44 |     public function isActive(): bool;
45 | }
46 | 


--------------------------------------------------------------------------------
/Reference/DtoInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | /**
 6 |  * For backward compatibility with custom containers,
 7 |  * this interface can only be extended.
 8 |  *
 9 |  * Для обратной совместимостью с пользовательскими контейнерами
10 |  * этот интерфейс может только расширяться.
11 |  */
12 | interface DtoInterface
13 | {
14 |     /**
15 |      * Get the value from the previous controller by the assigned name.
16 |      *
17 |      * Получить значение из предыдущего контроллера по назначенному имени.
18 |      */
19 |     public function get($name);
20 | 
21 |     /**
22 |      * Set value by name to use in next controller.
23 |      *
24 |      * Установить значение по имени для использования в следующем контроллере.
25 |      */
26 |     public function set($name, $value): void;
27 | 
28 |     /**
29 |      * Data can be cleared as soon as it is no longer needed.
30 |      *
31 |      * Данные можно очистить, как только они становятся не нужны.
32 |      */
33 |     public function clear(): void;
34 | 
35 |     /**
36 |      * Returns all assigned data in an array.
37 |      *
38 |      * Возвращает все присвоенные данные в массиве.
39 |      */
40 |     public function list(): array;
41 | }
42 | 


--------------------------------------------------------------------------------
/Reference/DtoReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Reference;
 6 | 
 7 | use Hleb\Base\RollbackInterface;
 8 | use Hleb\Constructor\Attributes\Accessible;
 9 | use Hleb\Constructor\Attributes\AvailableAsParent;
10 | use Hleb\Main\Insert\ContainerUniqueItem;
11 | 
12 | #[Accessible] #[AvailableAsParent]
13 | class DtoReference extends ContainerUniqueItem implements DtoInterface, Interface\Dto, RollbackInterface
14 | {
15 |     private static array $data = [];
16 | 
17 |     /** @internal */
18 |     public function __construct()
19 |     {
20 |         $this->rollback();
21 |     }
22 | 
23 |     /** @inheritDoc */
24 |     #[\Override]
25 |     public function get($name)
26 |     {
27 |         return self::$data[$name] ?? null;
28 |     }
29 | 
30 |     /** @inheritDoc */
31 |     #[\Override]
32 |     public function set($name, #[\SensitiveParameter] $value): void
33 |     {
34 |         self::$data[$name] = $value;
35 |     }
36 | 
37 |     /** @inheritDoc */
38 |     #[\Override]
39 |     public function clear(): void
40 |     {
41 |         $this->rollback();
42 |     }
43 | 
44 |     /** @inheritDoc */
45 |     #[\Override]
46 |     public function list(): array
47 |     {
48 |         return self::$data;
49 |     }
50 | 
51 |     /** @inheritDoc */
52 |     #[\Override]
53 |     public static function rollback(): void
54 |     {
55 |         self::$data = [];
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/Reference/Interface/Arr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\ArrInterface;
 6 | 
 7 | /**
 8 |  * @see ArrInterface
 9 |  */
10 | interface Arr extends ArrInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\CacheInterface;
 6 | 
 7 | /**
 8 |  * @see CacheInterface
 9 |  */
10 | interface Cache extends CacheInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Command.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\CommandInterface;
 6 | 
 7 | /**
 8 |  * @see CacheInterface
 9 |  */
10 | interface Command extends CommandInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Converter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\ConverterInterface;
 6 | 
 7 | /**
 8 |  * @see ConverterInterface
 9 |  */
10 | interface Converter extends ConverterInterface
11 | {
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/Reference/Interface/Cookie.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\CookieInterface;
 6 | 
 7 | /**
 8 |  * @see CookieInterface
 9 |  */
10 | interface Cookie extends CookieInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Csrf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\CsrfInterface;
 6 | 
 7 | /**
 8 |  * @see CsrfInterface
 9 |  */
10 | interface Csrf extends CsrfInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/DI.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\DiInterface;
 6 | 
 7 | /**
 8 |  * @see DiInterface
 9 |  */
10 | interface DI extends DiInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Db.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\DbInterface;
 6 | 
 7 | /**
 8 |  * @see DbInterface
 9 |  */
10 | interface Db extends DbInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Debug.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\DebugInterface;
 6 | 
 7 | /**
 8 |  * @see DebugInterface
 9 |  */
10 | interface Debug extends DebugInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Dto.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\DtoInterface;
 6 | 
 7 | /**
 8 |  * @see DtoInterface
 9 |  */
10 | interface Dto extends DtoInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Log.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\LogInterface;
 6 | 
 7 | /**
 8 |  * @see LogInterface
 9 |  */
10 | interface Log extends LogInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Path.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\PathInterface;
 6 | 
 7 | /**
 8 |  * @see PathInterface
 9 |  */
10 | interface Path extends PathInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Redirect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\RedirectInterface;
 6 | 
 7 | /**
 8 |  * @see RedirectInterface
 9 |  */
10 | interface Redirect extends RedirectInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Request.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\RequestInterface;
 6 | 
 7 | /**
 8 |  * @see RequestInterface
 9 |  */
10 | interface Request extends RequestInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Response.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\ResponseInterface;
 6 | 
 7 | /**
 8 |  * @see ResponseInterface
 9 |  */
10 | interface Response extends ResponseInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Router.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\RouterInterface;
 6 | 
 7 | /**
 8 |  * @see RouterInterface
 9 |  */
10 | interface Router extends RouterInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Session.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\SessionInterface;
 6 | 
 7 | /**
 8 |  * @see SessionInterface
 9 |  */
10 | interface Session extends SessionInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Setting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\SettingInterface;
 6 | 
 7 | /**
 8 |  * @see SettingInterface
 9 |  */
10 | interface Setting extends SettingInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/System.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\SystemInterface;
 6 | 
 7 | /**
 8 |  * @see SystemInterface
 9 |  */
10 | interface System extends SystemInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/Interface/Template.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference\Interface;
 4 | 
 5 | use Hleb\Reference\TemplateInterface;
 6 | 
 7 | /**
 8 |  * @see TemplateInterface
 9 |  */
10 | interface Template extends TemplateInterface
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/Reference/OnceInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | interface OnceInterface
 6 | {
 7 |     /**
 8 |      * @see once()
 9 |      */
10 |     public static function get(callable $func): mixed;
11 | 
12 |     public static function rollback(): void;
13 | }
14 | 


--------------------------------------------------------------------------------
/Reference/RedirectInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | interface RedirectInterface
 6 | {
 7 |     /**
 8 |      * Redirect to internal page or full URL.
 9 |      *
10 |      * Редирект на внутреннюю страницу или полный URL.
11 |      */
12 |     public function to(string $location, int $status = 302): void;
13 | }
14 | 


--------------------------------------------------------------------------------
/Reference/RedirectReference.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Reference;
 6 | 
 7 | use AsyncExitException;
 8 | use Hleb\Constructor\Attributes\Accessible;
 9 | use Hleb\Constructor\Attributes\AvailableAsParent;
10 | use Hleb\Main\Insert\ContainerUniqueItem;
11 | use Hleb\Static\Response;
12 | use Hleb\Static\Script;
13 | 
14 | #[Accessible] #[AvailableAsParent]
15 | class RedirectReference extends ContainerUniqueItem implements RedirectInterface, Interface\Redirect
16 | {
17 |     /**
18 |      * @inheritDoc
19 |      *
20 |      * @throws AsyncExitException
21 |      */
22 |     #[\Override]
23 |     public function to(string $location, int $status = 302): void
24 |     {
25 |         Script::asyncExit('', $status, \array_merge(Response::getHeaders(), ['Location' => $location]));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Reference/ScriptInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | use JetBrains\PhpStorm\NoReturn;
 6 | 
 7 | interface ScriptInterface
 8 | {
 9 |     /**
10 |      * Wrapper for classic script exit. Not applicable for asynchronous mode.
11 |      *
12 |      * Обёртка для классического выхода из скрипта. Неприменимо для асинхронного режима.
13 |      */
14 |     #[NoReturn]
15 |     public static function standardExit($message = '', int $httpCode = 200, array $headers = []): never;
16 | 
17 |     /**
18 |      * Simulation with exit from the process (script) for asynchronous mode
19 |      * and normal exit for standard mode.
20 |      *
21 |      * Имитация с выходом из процесса (скрипта) для асинхронного режима
22 |      * и обычный выход для стандартного режима.
23 |      */
24 |     public static function asyncExit($message = '', ?int $httpStatus = null, array $headers = []): never;
25 | }
26 | 


--------------------------------------------------------------------------------
/Reference/ViewInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Hleb\Reference;
 4 | 
 5 | use Hleb\Constructor\Data\View;
 6 | 
 7 | interface ViewInterface
 8 | {
 9 |     /**
10 |      * @see view()
11 |      */
12 |     public function view(string $template, array $params = [], ?int $status = null): View;
13 | }
14 | 


--------------------------------------------------------------------------------
/Route/After.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
15 | use Hleb\Main\Routes\StandardRoute;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class After extends StandardRoute
21 | {
22 |     use InsertMiddlewareTrait;
23 |     use InsertAfterTrait;
24 |     use InsertBeforeTrait;
25 |     use InsertWhereTrait;
26 |     use InsertProtectTrait;
27 |     use InsertNameTrait;
28 |     use InsertDomainTrait;
29 |     use InsertPlainTrait;
30 | 
31 |     public function __construct(string $target, ?string $method, array $data = [])
32 |     {
33 |         [$class, $method] = $this->searchMiddlewareAttributes($target, $method);
34 | 
35 |         $this->register([
36 |             'method' => self::AFTER_TYPE,
37 |             'class' => $class,
38 |             'class-method' => $method,
39 |             'from-group' => false,
40 |             'related-data' => $data,
41 |         ]);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Route/Alias.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\HlebBootstrap;
 8 | use Hleb\Main\Routes\StandardRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Alias extends StandardRoute
14 | {
15 |     public function __construct(string $route, string $newName, string $name)
16 |     {
17 |         $this->register([
18 |             'method' => self::ALIAS_SUBTYPE,
19 |             'name' => $name,
20 |             'new-name' => $newName,
21 |             'types' => $this->types(),
22 |             'data' => [
23 |                 'route' => $route,
24 |             ]
25 |         ]);
26 |     }
27 | 
28 |     protected function types(): array
29 |     {
30 |         return HlebBootstrap::HTTP_TYPES;
31 |     }
32 | 
33 |     protected function methodName(): string
34 |     {
35 |         return self::ALIAS_SUBTYPE;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Route/Any.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\HlebBootstrap;
 8 | use Hleb\Main\Routes\Methods\BaseType;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Any extends BaseType
14 | {
15 |     #[\Override]
16 |     protected function types(): array
17 |     {
18 |         return HlebBootstrap::HTTP_TYPES;
19 |     }
20 | 
21 |     #[\Override]
22 |     protected function methodName(): string
23 |     {
24 |         return self::ANY_SUBTYPE;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/Route/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
15 | use Hleb\Main\Routes\StandardRoute;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class Controller extends StandardRoute
21 | {
22 |     use InsertWhereTrait;
23 |     use InsertProtectTrait;
24 |     use InsertNameTrait;
25 |     use InsertMiddlewareTrait;
26 |     use InsertAfterTrait;
27 |     use InsertBeforeTrait;
28 |     use InsertDomainTrait;
29 |     use InsertPlainTrait;
30 | 
31 |     public function __construct(string $target, ?string $method = null)
32 |     {
33 |         [$class, $method] = $this->getControllerAttributes($target, $method);
34 | 
35 |         $this->register([
36 |             'method' => self::CONTROLLER_TYPE,
37 |             'class' => $class,
38 |             'class-method' => $method,
39 |         ]);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Route/Delete.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Delete extends BaseType
13 | {
14 |     #[\Override]
15 |     protected function types(): array
16 |     {
17 |         return ['DELETE', 'OPTIONS'];
18 |     }
19 | 
20 |     #[\Override]
21 |     protected function methodName(): string
22 |     {
23 |         return self::DELETE_SUBTYPE;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Domain.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
17 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
18 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
19 | use Hleb\Main\Routes\StandardRoute;
20 | 
21 | /**
22 |  * @internal
23 |  */
24 | final class Domain extends StandardRoute
25 | {
26 |     use InsertWhereTrait;
27 |     use InsertControllerTrait;
28 |     use InsertPageTrait;
29 |     use InsertMiddlewareTrait;
30 |     use InsertAfterTrait;
31 |     use InsertBeforeTrait;
32 |     use InsertProtectTrait;
33 |     use InsertModuleTrait;
34 |     use InsertNameTrait;
35 |     use InsertDomainTrait;
36 |     use InsertPlainTrait;
37 |     use InsertRedirectTrait;
38 | 
39 |     public function __construct(string|array $part, int $level = 2)
40 |     {
41 |         $this->register([
42 |             'method' => self::DOMAIN_TYPE,
43 |             'name' => \is_array($part) ? $part : [$part],
44 |             'level' => $level
45 |         ]);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Route/Get.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Get extends BaseType
13 | {
14 |     #[\Override]
15 |     protected function types(): array
16 |     {
17 |         return ['GET', 'OPTIONS'];
18 |     }
19 | 
20 |     #[\Override]
21 |     protected function methodName(): string
22 |     {
23 |         return self::GET_SUBTYPE;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Group/EndGroup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\StandardRoute;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class EndGroup extends StandardRoute
13 | {
14 |     public function __construct()
15 |     {
16 |         $this->register([
17 |             'method' => self::END_GROUP_TYPE,
18 |         ]);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/Route/Group/GroupAfter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class GroupAfter extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct(string $target, ?string $method = null, array $data = [])
22 |     {
23 |         [$class, $method] = $this->searchMiddlewareAttributes($target, $method);
24 | 
25 |         $this->register([
26 |             'method' => self::AFTER_TYPE,
27 |             'class' => $class,
28 |             'class-method' => $method,
29 |             'from-group' => true,
30 |             'related-data' => $data,
31 |         ]);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Route/Group/GroupDomain.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class GroupDomain extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct(string|array $part, int $level = 2)
22 |     {
23 |         $this->register([
24 |             'method' => self::DOMAIN_TYPE,
25 |             'name' => \is_array($part) ? $part : [$part],
26 |             'level' => $level,
27 |             'from-group' => true
28 |         ]);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Route/Group/GroupMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class GroupMiddleware extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct(string $target, ?string $method = null, array $data = [])
22 |     {
23 |         [$class, $method] = $this->searchMiddlewareAttributes($target, $method);
24 | 
25 |         $this->register([
26 |             'method' => self::MIDDLEWARE_TYPE,
27 |             'class' => $class,
28 |             'class-method' => $method,
29 |             'from-group' => true,
30 |             'related-data' => $data,
31 |         ]);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Route/Group/GroupNoDebug.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
 8 | use Hleb\Main\Routes\StandardRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class GroupNoDebug extends StandardRoute
14 | {
15 |     use StandardGroupTrait;
16 | 
17 |     public function __construct()
18 |     {
19 |         $this->register([
20 |             'method' => self::NO_DEBUG_TYPE,
21 |             'from-group' => true,
22 |         ]);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Route/Group/GroupPlain.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
 8 | use Hleb\Main\Routes\StandardRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class GroupPlain extends StandardRoute
14 | {
15 |     use StandardGroupTrait;
16 | 
17 |     public function __construct(bool $on = true)
18 |     {
19 |         $this->register([
20 |             'method' => self::PLAIN_TYPE,
21 |             'from-group' => true,
22 |             'data' => ['on' => $on],
23 |         ]);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Group/GroupPrefix.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class GroupPrefix extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct(string $prefix)
22 |     {
23 |         $this->register([
24 |             'method' => self::PREFIX_TYPE,
25 |             'prefix' => $prefix,
26 |             'from-group' => true
27 |         ]);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Route/Group/GroupProtect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
 8 | use Hleb\Main\Routes\StandardRoute;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class GroupProtect extends StandardRoute
14 | {
15 |     use StandardGroupTrait;
16 | 
17 |     public function __construct(string|array $rules)
18 |     {
19 |         \is_string($rules) and $rules = [$rules];
20 | 
21 |         $this->register([
22 |             'method' => self::PROTECT_TYPE,
23 |             'from-group' => true,
24 |             'data' => ['rules' => $rules],
25 |         ]);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Route/Group/GroupWhere.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class GroupWhere extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct(array $rules)
22 |     {
23 |         $this->register([
24 |             'method' => self::WHERE_TYPE,
25 |             'data' => [
26 |                 'rules' => $rules,
27 |             ],
28 |             'from-group' => true
29 |         ]);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/Route/Group/ToGroup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Route\Group;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\Group\GroupPlainTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\Group\GroupProtectTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\Group\StandardGroupTrait;
10 | use Hleb\Main\Routes\StandardRoute;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class ToGroup extends StandardRoute
16 | {
17 |     use StandardGroupTrait;
18 |     use GroupPlainTrait;
19 |     use GroupProtectTrait;
20 | 
21 |     public function __construct()
22 |     {
23 |         $this->register([
24 |             'method' => self::TO_GROUP_TYPE,
25 |         ]);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Route/MatchTypes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Constructor\Data\View;
 8 | use Hleb\Main\Routes\Methods\BaseType;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class MatchTypes extends BaseType
14 | {
15 |     public function __construct(
16 |         readonly private array     $types,
17 |         string                     $route,
18 |         float|View|int|string|null $view = null)
19 |     {
20 |         parent::__construct($route, $view);
21 |     }
22 | 
23 |     #[\Override]
24 |     protected function types(): array
25 |     {
26 |         return \array_unique(\array_merge($this->types, ['OPTIONS']));
27 |     }
28 | 
29 |     #[\Override]
30 |     protected function methodName(): string
31 |     {
32 |         return self::MATCH_SUBTYPE;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Route/Middleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
15 | use Hleb\Main\Routes\StandardRoute;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class Middleware extends StandardRoute
21 | {
22 |     use InsertMiddlewareTrait;
23 |     use InsertAfterTrait;
24 |     use InsertBeforeTrait;
25 |     use InsertWhereTrait;
26 |     use InsertProtectTrait;
27 |     use InsertNameTrait;
28 |     use InsertDomainTrait;
29 |     use InsertPlainTrait;
30 | 
31 |     public function __construct(string $target, ?string $method, array $data = [])
32 |     {
33 |         [$class, $method] = $this->searchMiddlewareAttributes($target, $method);
34 | 
35 |         $this->register([
36 |             'method' => self::MIDDLEWARE_TYPE,
37 |             'class' => $class,
38 |             'class-method' => $method,
39 |             'from-group' => false,
40 |             'related-data' => $data,
41 |         ]);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Route/Module.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
15 | use Hleb\Main\Routes\StandardRoute;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class Module extends StandardRoute
21 | {
22 |     use InsertWhereTrait;
23 |     use InsertProtectTrait;
24 |     use InsertNameTrait;
25 |     use InsertMiddlewareTrait;
26 |     use InsertAfterTrait;
27 |     use InsertBeforeTrait;
28 |     use InsertDomainTrait;
29 |     use InsertPlainTrait;
30 | 
31 |     public function __construct(string $name, string $target, ?string $method = null)
32 |     {
33 |         [$class, $method] = $this->searchModuleAttributes($name, $target, $method);
34 | 
35 |         $this->register([
36 |             'method' => self::MODULE_TYPE,
37 |             'name' => $name,
38 |             'class' => $class,
39 |             'class-method' => $method,
40 |         ]);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Route/Name.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
17 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
18 | use Hleb\Main\Routes\StandardRoute;
19 | 
20 | /**
21 |  * @internal
22 |  */
23 | final class Name extends StandardRoute
24 | {
25 |     use InsertWhereTrait;
26 |     use InsertControllerTrait;
27 |     use InsertMiddlewareTrait;
28 |     use InsertAfterTrait;
29 |     use InsertBeforeTrait;
30 |     use InsertProtectTrait;
31 |     use InsertModuleTrait;
32 |     use InsertDomainTrait;
33 |     use InsertPageTrait;
34 |     use InsertPlainTrait;
35 |     use InsertRedirectTrait;
36 | 
37 |     public function __construct(string $name)
38 |     {
39 |         $this->register([
40 |             'method' => self::NAME_TYPE,
41 |             'name' => $name
42 |         ]);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Route/NoDebug.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
17 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
18 | use Hleb\Main\Routes\StandardRoute;
19 | 
20 | /**
21 |  * @internal
22 |  */
23 | final class NoDebug extends StandardRoute
24 | {
25 |     use InsertWhereTrait;
26 |     use InsertControllerTrait;
27 |     use InsertMiddlewareTrait;
28 |     use InsertAfterTrait;
29 |     use InsertBeforeTrait;
30 |     use InsertNameTrait;
31 |     use InsertProtectTrait;
32 |     use InsertModuleTrait;
33 |     use InsertDomainTrait;
34 |     use InsertPageTrait;
35 |     use InsertRedirectTrait;
36 | 
37 |     public function __construct()
38 |     {
39 |         $this->register([
40 |             'method' => self::NO_DEBUG_TYPE,
41 |             'from-group' => false,
42 |         ]);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/Route/Options.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Options extends BaseType
13 | {
14 |     public function __construct(string $route)
15 |     {
16 |         parent::__construct($route);
17 |     }
18 | 
19 |     #[\Override]
20 |     protected function types(): array
21 |     {
22 |         return ['OPTIONS'];
23 |     }
24 | 
25 |     #[\Override]
26 |     protected function methodName(): string
27 |     {
28 |         return self::OPTIONS_SUBTYPE;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Route/Page.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
15 | use Hleb\Main\Routes\StandardRoute;
16 | 
17 | /**
18 |  * @internal
19 |  */
20 | final class Page extends StandardRoute
21 | {
22 |     use InsertWhereTrait;
23 |     use InsertProtectTrait;
24 |     use InsertNameTrait;
25 |     use InsertMiddlewareTrait;
26 |     use InsertAfterTrait;
27 |     use InsertBeforeTrait;
28 |     use InsertDomainTrait;
29 |     use InsertPlainTrait;
30 | 
31 |     public function __construct(string $type, string $target, ?string $method = null)
32 |     {
33 |         [$class, $method] = $this->getControllerAttributes($target, $method);
34 | 
35 |         $this->register([
36 |             'method' => self::PAGE_TYPE,
37 |             'name' => $type,
38 |             'class' => $class,
39 |             'class-method' => $method,
40 |         ]);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Route/Patch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Patch extends BaseType
13 | {
14 |     #[\Override]
15 |     protected function types(): array
16 |     {
17 |         return ['PATCH', 'OPTIONS'];
18 |     }
19 | 
20 |     #[\Override]
21 |     protected function methodName(): string
22 |     {
23 |         return self::PATCH_SUBTYPE;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Plain.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
17 | use Hleb\Main\Routes\StandardRoute;
18 | 
19 | /**
20 |  * @internal
21 |  */
22 | final class Plain extends StandardRoute
23 | {
24 |     use InsertWhereTrait;
25 |     use InsertControllerTrait;
26 |     use InsertMiddlewareTrait;
27 |     use InsertAfterTrait;
28 |     use InsertBeforeTrait;
29 |     use InsertNameTrait;
30 |     use InsertModuleTrait;
31 |     use InsertDomainTrait;
32 |     use InsertPageTrait;
33 |     use InsertRedirectTrait;
34 | 
35 |     public function __construct(bool $on = true)
36 |     {
37 |         $this->register([
38 |             'method' => self::PLAIN_TYPE,
39 |             'from-group' => false,
40 |             'data' => ['on' => $on],
41 |         ]);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/Route/Post.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Post extends BaseType
13 | {
14 |     #[\Override]
15 |     protected function types(): array
16 |     {
17 |         return ['POST', 'OPTIONS'];
18 |     }
19 | 
20 |     #[\Override]
21 |     protected function methodName(): string
22 |     {
23 |         return self::POST_SUBTYPE;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Protect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
17 | use Hleb\Main\Routes\StandardRoute;
18 | 
19 | /**
20 |  * @internal
21 |  */
22 | final class Protect extends StandardRoute
23 | {
24 |     use InsertWhereTrait;
25 |     use InsertControllerTrait;
26 |     use InsertMiddlewareTrait;
27 |     use InsertAfterTrait;
28 |     use InsertBeforeTrait;
29 |     use InsertNameTrait;
30 |     use InsertModuleTrait;
31 |     use InsertDomainTrait;
32 |     use InsertPageTrait;
33 |     use InsertRedirectTrait;
34 | 
35 |     public function __construct(string|array $rules)
36 |     {
37 |         \is_string($rules) and $rules = [$rules];
38 | 
39 |         $this->register([
40 |             'method' => self::PROTECT_TYPE,
41 |             'from-group' => false,
42 |             'data' => ['rules' => $rules],
43 |         ]);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/Route/Put.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\BaseType;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class Put extends BaseType
13 | {
14 |     #[\Override]
15 |     protected function types(): array
16 |     {
17 |         return ['PUT', 'OPTIONS'];
18 |     }
19 | 
20 |     #[\Override]
21 |     protected function methodName(): string
22 |     {
23 |         return self::PUT_SUBTYPE;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Route/Redirect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertWhereTrait;
14 | use Hleb\Main\Routes\StandardRoute;
15 | 
16 | /**
17 |  * @internal
18 |  */
19 | final class Redirect extends StandardRoute
20 | {
21 |     use InsertWhereTrait;
22 |     use InsertProtectTrait;
23 |     use InsertNameTrait;
24 |     use InsertMiddlewareTrait;
25 |     use InsertBeforeTrait;
26 |     use InsertDomainTrait;
27 |     use InsertPlainTrait;
28 | 
29 |     public function __construct(string $location, int $status = 302)
30 |     {
31 |         $this->register([
32 |             'method' => self::REDIRECT_TYPE,
33 |             'location' => $location,
34 |             'status' => $status,
35 |         ]);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Route/Where.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Hleb\Route;
 6 | 
 7 | use Hleb\Main\Routes\Methods\Traits\InsertAfterTrait;
 8 | use Hleb\Main\Routes\Methods\Traits\InsertBeforeTrait;
 9 | use Hleb\Main\Routes\Methods\Traits\InsertControllerTrait;
10 | use Hleb\Main\Routes\Methods\Traits\InsertDomainTrait;
11 | use Hleb\Main\Routes\Methods\Traits\InsertMiddlewareTrait;
12 | use Hleb\Main\Routes\Methods\Traits\InsertModuleTrait;
13 | use Hleb\Main\Routes\Methods\Traits\InsertNameTrait;
14 | use Hleb\Main\Routes\Methods\Traits\InsertPlainTrait;
15 | use Hleb\Main\Routes\Methods\Traits\InsertPageTrait;
16 | use Hleb\Main\Routes\Methods\Traits\InsertProtectTrait;
17 | use Hleb\Main\Routes\Methods\Traits\InsertRedirectTrait;
18 | use Hleb\Main\Routes\StandardRoute;
19 | 
20 | /**
21 |  * @internal
22 |  */
23 | final class Where extends StandardRoute
24 | {
25 |     use InsertControllerTrait;
26 |     use InsertMiddlewareTrait;
27 |     use InsertAfterTrait;
28 |     use InsertBeforeTrait;
29 |     use InsertProtectTrait;
30 |     use InsertNameTrait;
31 |     use InsertModuleTrait;
32 |     use InsertDomainTrait;
33 |     use InsertPageTrait;
34 |     use InsertPlainTrait;
35 |     use InsertRedirectTrait;
36 | 
37 |     public function __construct(array $rules)
38 |     {
39 |         $this->register([
40 |             'method' => self::WHERE_TYPE,
41 |             'data' => [
42 |                 'rules' => $rules,
43 |             ]
44 |         ]);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/Static/Command.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Static;
 6 | 
 7 | use App\Bootstrap\BaseContainer;
 8 | use Hleb\Base\Task;
 9 | use Hleb\Constructor\Attributes\Accessible;
10 | use Hleb\Constructor\Attributes\ForTestOnly;
11 | use Hleb\CoreProcessException;
12 | use Hleb\Main\Insert\BaseSingleton;
13 | use Hleb\Reference\CommandInterface;
14 | 
15 | #[Accessible]
16 | final class Command extends BaseSingleton
17 | {
18 |     private static CommandInterface|null $replace = null;
19 | 
20 |     /**
21 |      * Execute an initiated command object with arguments.
22 |      *
23 |      * Выполнение инициированного объекта команды с аргументами.
24 |      */
25 |     public static function execute(Task $task, array $arguments = []): mixed
26 |     {
27 |         if (self::$replace) {
28 |             return self::$replace->execute($task, $arguments);
29 |         }
30 | 
31 |         return BaseContainer::instance()->get(CommandInterface::class)->execute($task, $arguments);
32 |     }
33 | 
34 |     /**
35 |      * @internal
36 |      *
37 |      * @see CommandForTest
38 |      */
39 |     #[ForTestOnly]
40 |     public static function replaceWithMock(CommandInterface|null $mock): void
41 |     {
42 |         if (\defined('HLEB_CONTAINER_MOCK_ON') && !HLEB_CONTAINER_MOCK_ON) {
43 |             throw new CoreProcessException('The action is prohibited in the settings.');
44 |         }
45 |         self::$replace = $mock;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/Static/Redirect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | namespace Hleb\Static;
 6 | 
 7 | use App\Bootstrap\BaseContainer;
 8 | use Hleb\Constructor\Attributes\Accessible;
 9 | use Hleb\Constructor\Attributes\ForTestOnly;
10 | use Hleb\CoreProcessException;
11 | use Hleb\Main\Insert\BaseSingleton;
12 | use Hleb\Reference\RedirectInterface;
13 | 
14 | #[Accessible]
15 | final class Redirect extends BaseSingleton
16 | {
17 |     private static RedirectInterface|null $replace = null;
18 | 
19 |     /**
20 |      * Redirect to internal page or full URL.
21 |      *
22 |      * Редирект на внутреннюю страницу или полный URL.
23 |      *
24 |      * @param string $location - redirect target, full or relative URL.
25 |      *                         - цель редиректа, полный или относительный URL.
26 |      *
27 |      * @param int $status - response code of the current HTTP request for the redirect.
28 |      *                    - код ответа текущего HTTP-запроса для редиректа.
29 |      */
30 |     public static function to(string $location, int $status = 302): void
31 |     {
32 |         if (self::$replace) {
33 |             self::$replace->to($location, $status);
34 |         } else {
35 |             BaseContainer::instance()->get(RedirectInterface::class)->to($location, $status);
36 |         }
37 |     }
38 | 
39 |     /**
40 |      * @internal
41 |      *
42 |      * @see RedirectForTest
43 |      */
44 |     #[ForTestOnly]
45 |     public static function replaceWithMock(RedirectInterface|null $mock): void
46 |     {
47 |         if (\defined('HLEB_CONTAINER_MOCK_ON') && !HLEB_CONTAINER_MOCK_ON) {
48 |             throw new CoreProcessException('The action is prohibited in the settings.');
49 |         }
50 |         self::$replace = $mock;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/bootstrap.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | use Hleb\HlebBootstrap;
 9 | 
10 | PHP_VERSION_ID < 80200 and exit('Current PHP version is ' . PHP_VERSION . ', required >= 8.2');
11 | 
12 | \class_exists(HlebBootstrap::class) or require __DIR__ . '/HlebBootstrap.php';
13 | 
14 | (new HlebBootstrap(HLEB_PUBLIC_DIR))->load();
15 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "phphleb/framework",
 3 |     "description": "Engine for Framework HLEB2",
 4 |     "type": "library",
 5 |     "homepage": "https://hleb2framework.ru",
 6 |     "keywords": [
 7 |         "hleb2",
 8 |         "phphleb",
 9 |         "framework",
10 |         "php framework",
11 |         "php"
12 |     ],
13 |     "license": "MIT",
14 |     "authors": [
15 |         {
16 |             "name": "Foma Tuturov",
17 |             "email": "fomiash@yandex.ru"
18 |         }
19 |     ],
20 |     "autoload": {
21 |         "psr-4": {
22 |             "Hleb\\": "/"
23 |         }
24 |     },
25 |     "require": {
26 |         "php": ">=8.2.0",
27 |         "phphleb/debugpan": "^2.0.0",
28 |         "phphleb/nicejson": "*",
29 |         "phphleb/salt": "*"
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/console.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * @author  Foma Tuturov <fomiash@yandex.ru>
 4 |  */
 5 | 
 6 | declare(strict_types=1);
 7 | 
 8 | use Hleb\HlebBootstrap;
 9 | use Hleb\HlebConsoleBootstrap;
10 | 
11 | PHP_VERSION_ID < 80200 and exit('Current PHP version is ' . PHP_VERSION . ', required >= 8.2' . PHP_EOL);
12 | 
13 | HLEB_PUBLIC_DIR or exit('Error! The public directory in the \'/console\' file is incorrectly specified.');
14 | 
15 | \class_exists(HlebBootstrap::class) or require __DIR__ . '/HlebBootstrap.php';
16 | \class_exists(HlebConsoleBootstrap::class) or require __DIR__ . '/HlebConsoleBootstrap.php';
17 | 
18 | exit((new HlebConsoleBootstrap(HLEB_PUBLIC_DIR))->load());
19 | 


--------------------------------------------------------------------------------
/preload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * By connecting this script to php.ini, you can achieve an increase
 4 |  * in the performance of the framework in opcache mode.
 5 |  *
 6 |  * Подключив этот скрипт в php.ini можно добиться прироста
 7 |  * производительности фреймворка в режиме opcache.
 8 |  *
 9 |  * ```
10 |  *  opcache.preload=/path/to/project/vendor/phphleb/framework/preload.php
11 |  * ```
12 |  */
13 | 
14 | use Hleb\Init\Connectors\HlebConnector;
15 | 
16 | if (!class_exists(HlebConnector::class, false)) {
17 |     $dir = realpath(__DIR__);
18 |     include $dir . '/Init/Connectors/HlebConnector.php';
19 | 
20 |     $map = HlebConnector::$map;
21 |     array_walk($map, function (&$path) use ($dir): void {
22 |         $path = $dir . $path;
23 |     });
24 | 
25 |     if (!function_exists('search_root')) {
26 |         include $dir . '/Init/Connectors/Preload/search-functions.php';
27 |     }
28 |     $root = search_root();
29 |     foreach (HlebConnector::$bootstrapMap as $file) {
30 |         $map[] = $root . $file;
31 |     }
32 | 
33 |     $routeDir = \realpath($root . '/storage/cache/routes');
34 |     if (is_dir($routeDir)) {
35 |         $map = array_merge($map, search_php_files($routeDir));
36 |     }
37 | 
38 |     if (!function_exists('get_env')) {
39 |         $map[] = $dir . '/Init/Review/basic.php';
40 |     }
41 |     if (!function_exists('hl_debug')) {
42 |         $map[] = $dir . '/Init/Review/functions.php';
43 |     }
44 | 
45 |     if (function_exists('opcache_compile_file')) {
46 |         foreach ($map as $file) {
47 |             @opcache_compile_file($file);
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | Engine for PHP Framework HLEB2
 2 | =====================
 3 | 
 4 | ![HLEB2](https://img.shields.io/badge/HLEB-2-darkcyan)
 5 | ![PHP](https://img.shields.io/badge/PHP-^8.2-blue)
 6 | [![License: MIT](https://img.shields.io/badge/License-MIT%20(Free)-brightgreen.svg)](https://github.com/phphleb/hleb/blob/master/LICENSE)
 7 | [![build](https://github.com/phphleb/framework/actions/workflows/build.yml/badge.svg?event=push)](https://github.com/phphleb/framework/actions/workflows/build.yml)
 8 | 
 9 | If you need to install the framework, use the link: [github.com/phphleb/hleb](https://github.com/phphleb/hleb)
10 | 
11 | A distinctive feature of the PHP framework HLEB2 is the minimalism of the code and the speed of work. The choice of this framework allows you to launch a full-fledged product with minimal time costs and appeals to documentation; it is easy, simple and fast.
12 | At the same time, it solves typical tasks, such as routing, shifting actions to controllers, model support, so, the basic MVC implementation. This is the very minimum you need to quickly launch an application.
13 | 
14 | 📄 [**Issue Template**](https://github.com/phphleb/framework/blob/master/.github/ISSUE_TEMPLATE.md)
15 | 
16 | 📄 [**Pull Request Template**](https://github.com/phphleb/framework/blob/master/.github/PULL_REQUEST_TEMPLATE.md)
17 | 
18 | 📄 [**Security Info**](https://github.com/phphleb/framework/blob/master/.github/SECURITY.md)
19 | 


--------------------------------------------------------------------------------
/web/css/default.css:
--------------------------------------------------------------------------------
1 | html,body{padding:0;margin:0;width:100%;height:95%;max-height:100%;max-width:100%;color:#353478;font-size:16px;background-color:#f9f9f9;font-family:"PT Sans","Arial",serif}.wrapper{display:flex}.header{width:100%}.header-version,.header-block,.header-indent{display:inline-block;padding:17px 2px 8px;background-color:#fff;font-weight:bolder}.header-indent{padding:0;width:5px}.header-block{flex-grow:1}.header-version{border-bottom:3px solid #E65F4B}.footer{position:fixed;left:0;bottom:0;padding:10px 0 16px 0;background:#28396c;font-weight:400;color:#fff;width:100%;border-top:1px solid #c2bfbf;font-size:14px}.repository{display:inline-block;margin-left:10px}.footer a{color:#fff;text-decoration:none;white-space:nowrap}.footer-link{display:inline-block;width:max-content;transform:rotate(270deg);font-size:18px}.php-version{display:inline-block;margin:5px 10px;float:right}.content-wrapper{display:flex;align-items:center;justify-content:center;margin-top:10%;margin-right:10px}.content{display:inline-block;margin-bottom:60px}.text{margin-top:15px;text-align:center}#hlogin-info-block{margin:20px 2px 20px 8px;align-content:center}.hlogin-info-selector a{color:#353478}.hlogin-ui-btn button{padding:5px 10px;margin:5px 10px;width:200px;text-align:left;cursor:pointer}.hlogin-ui-content{margin-top:1%}


--------------------------------------------------------------------------------
/web/css/error-origin.css:
--------------------------------------------------------------------------------
 1 | html, body {
 2 |     padding: 0;
 3 |     margin: 0;
 4 |     width: 100%;
 5 |     height: 100%;
 6 |     background-color: white;
 7 | }
 8 | 
 9 | .hl-error-page-content {
10 |     position: fixed;
11 |     pointer-events: none;
12 |     text-align: center;
13 |     left: 0;
14 |     top: 0;
15 |     width: 100%;
16 |     height: 100%;
17 | }
18 | 
19 | .hl-error-page-message {
20 |     position: absolute;
21 |     top: calc(50% - 40px);
22 |     left: 50%;
23 |     transform: translate(-50%);
24 |     max-width: 90%;
25 |     color: #B4ACA6;
26 |     font-family: "PT Sans", "Arial", serif;
27 |     font-size: 30px;
28 |     opacity: 0.6;
29 |     white-space: nowrap;
30 | }
31 | 
32 | .hl-error-page-code {
33 |     display: inline-block;
34 |     font-size: 36px;
35 |     position: relative;
36 |     top: 2px;
37 |     right: 5px;
38 | }
39 | 
40 | @media only screen and (max-width: 400px) {
41 |     .hl-error-page-message {
42 |         font-size: 15px
43 |     }
44 |     .hl-error-page-code {
45 |         font-size: 15px;
46 |         top: 0;
47 |         right: 0;
48 |     }
49 | }


--------------------------------------------------------------------------------
/web/css/error.css:
--------------------------------------------------------------------------------
1 | html,body{padding:0;margin:0;width:100%;height:100%;background-color:#fff}.hl-error-page-content{position:fixed;pointer-events:none;text-align:center;left:0;top:0;width:100%;height:100%}.hl-error-page-message{position:absolute;top:calc(50% - 40px);left:50%;transform:translate(-50%);max-width:90%;color:#B4ACA6;font-family:"PT Sans","Arial",serif;font-size:30px;opacity:.6;white-space:nowrap}.hl-error-page-code{display:inline-block;font-size:36px;position:relative;top:2px;right:5px}@media only screen and (max-width:400px){.hl-error-page-message{font-size:15px}.hl-error-page-code{font-size:15px;top:0;right:0}}


--------------------------------------------------------------------------------
/web/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*declare(strict_types=1);*/
 4 | 
 5 | /**
 6 |  * Outputting native CSS resources of the framework.
 7 |  *
 8 |  * Вывод собственных CSS-ресурсов фреймворка.
 9 |  */
10 | 
11 | use Hleb\Constructor\Data\SystemSettings;
12 | use Hleb\HttpMethods\External\SystemRequest;
13 | use Hleb\Static\Response;
14 | 
15 | /**
16 |  * @var SystemRequest $request
17 |  */
18 | $address = \explode('/', \trim($request->getUri()->getPath(), '/'));
19 | $name = \end($address);
20 | 
21 | if (\in_array($name, ['error', 'default'])) {
22 |     $file = SystemSettings::getRealPath('@library/framework/web/css/' . $name . '.css');
23 | 
24 |     if (!$file) {
25 |         return false;
26 |     }
27 |     Response::addHeaders([
28 |         'Content-Type' => 'text/css; charset=UTF-8',
29 |     ]);
30 | } else if ($name === 'logo') {
31 |     $file = SystemSettings::getRealPath('@library/framework/web/svg/' . $name . '.svg');
32 | 
33 |     if (!$file) {
34 |         return false;
35 |     }
36 |     Response::addHeaders([
37 |         'Content-Type' => 'image/svg+xml; charset=UTF-8',
38 |     ]);
39 | } else {
40 |     return false;
41 | }
42 | Response::addHeaders([
43 |     'Cache-Control' => 'public, max-age=31536000',
44 |     'Pragma' => 'cache'
45 | ]);
46 | isset($file) and Response::setBody(\file_get_contents($file));
47 | 
48 | return true;
49 | 


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