Learn How to Use PHP MVC Frameworks to Organize Better PHP Projects Using the Package Luminova Framework: PHP Luminova framework: simple, powerful MVC/HMVC.

Recommend this page to a friend!

Download

Info

Documentation

Demos

Videos

Files

Install with Composer

Download

Reputation

Support forum

Blog

Links

Last Updated		Ratings				Unique User Downloads		Download Rankings
2024-09-03 (Less than 1 hour ago)		Not yet rated by the users				Total: 36		All time: 10,974 This week: 59

Version		License		PHP version		Categories
`luminova` 3.2.11		MIT/X Consortium ...		8.0		Tools, Libraries, Templates, Console, C..., D..., P...

Description

Author

Ujah Chigozie peter

PHP Luminova Framework is a robust MVC and HMVC framework, supporting Twig, Smarty, and PHP templating with layout inheritance and extensions using methods like `begin`, `end`, `import`, and `extend`.

It also offers:

- Unique database caching and ORM for query builders.

- Database migration and seeding with `NovaKit` commands for execution, rollback, and version control.

- Template view caching and built-in DOM minification configurable via the env file.

- OpenAI models for creating AI-powered applications.

- Command-line tools for building CLI tools and managing the framework via `NovaKit CLI`.

- Sitemap generation with a single `NovaKit` command.

- CronJobs management for scheduling and execution using the `NovaKit` command.

- Easy SCO schema object integration on web pages.

- Optimized HTTP and CLI routing.

- Cloud Storages, support different storage types like Locale, AWS S3, Azure Blob, Google Cloud Storage, etc.

- Support symlink creation for local and cloud storage that supports temporal public URLs.

- CDN module for local storage, to deliver files in the browser without the need for `symlink`, it also supports browser caching, large files, and any file type.

- Easy file uploads with support for browser-side chunking using libraries `Pluupload.js` etc.

- Utility classes and helper functions for various tasks.

- Comprehensive error handling and logging, along with support for maintenance mode.

Ujah Chigozie peter

Performance

Level

Name:	Ujah Chigozie peter `<contact>`
Classes:	26 packages by Ujah Chigozie peter
Country:	Nigeria

Level 4

Innovation award

Nominee: 11x

Instructions

The Framework You Didn't Know You Needed to Illuminate Your Project

PHP Luminova is a web development framework for PHP 8 and above, it's simple yet powerful, supporting both MVC and HMVC architectures, Twig, Smarty, and PHP templating with layout inheritance and extending.

Luminova comes packed with useful modules for application security and optimization.

Whether you prefer routing using PHP attributes or traditional code-based routing, we've got you covered.

Should I Try This?

If you want a simple framework that gives you everything you need for small to large applications.
If you want a framework that is easy to start with and easy to read and understand the code.
If you want a framework that allows you to utilize all PHP 8 features.
If you want a framework that requires minimal to no configuration.
If you don't mind receiving new feature updates every week.

Important Information

You can install the package from the PHP Classes Composer repository following the instructions in the Download tab.

Alternatively, you can download Luminova as a ZIP or .tar.gz archive. After extracting the archive to your preferred directory, run the following command to install the required modules:

composer update

Installing Luminova via Composer is recommended for easy updates:

composer create-project luminovang/luminova my-project

Manual Download

Download the latest version from Luminova's official website: Download Luminova.

Alternatively, you can manually download it from GitHub by following the instructions here: Installation Guide.

What is On Latest Update

You can now define routes using the PHP8 attribute (e.g., #[Route('/', methods: ['GET', 'POST'])]).

Optimization

Enhanced the global `env` function to support returning arrays, allowing variables like `my_array = ['foo', 'bar']`.

New Features

Static Content

Supports serving partially static content to improve performance. Enable page.caching in your env file and append an extension (e.g., .html) to your request URL. This reduces view response time by up to 10% by loading cached pages without invoking controller methods and other modules.

Example: - Original URL: https://example.com/blog/how-to-install-luminova - Static URL: https://example.com/blog/how-to-install-luminova.html

> Note: When a content extension is specified, application events and middleware are bypassed.

Documentation

Template and Controller View Handling

This documentation covers the basic implementation of template handling within the Luminova framework controllers.

Controller Overview

Controllers are classes that handle requests made to your application, whether they originate from HTTP requests or CLI commands. Upon initialization, a controller method processes the request, receiving all necessary parameters and dependencies. After processing the information, the controller renders the response or handles it accordingly. All controller classes should be placed in the /app/Controllers/ directory.

HTTP Controllers

Luminova provides two base controller classes for handling HTTP requests, both of which manage requests in a similar manner but differ in their initialization processes.

Base Controller

Extending Luminova\Base\BaseController automatically initializes the HTTP request class \Luminova\Http\Request and the input validation class Luminova\Security\Validation.

// /app/Controllers/MyController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;

class MyController extends BaseController 
{
    //...
}

Base View Controller

Extending Luminova\Base\BaseViewController does not automatically initialize any additional classes, allowing for manual initialization when necessary. This is particularly useful for web pages that do not require immediate user input validation.

// /app/Controllers/MyController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseViewController;

class MyController extends BaseViewController 
{
    //...
}

Base Command

Extending Luminova\Base\BaseCommand allows the controller to handle command line operations in a manner similar to HTTP controllers. For more details on command line implementation, see examples.

// /app/Controllers/MyCommand.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseCommand;

class MyCommand extends BaseCommand 
{
    //...
}

Rendering Controller Responses

In Luminova, you have multiple ways to handle and respond to requests. You can use the Luminova\Template\Response class, which provides a global response function, or utilize the Template View handling class, readily available in the core application object. The primary difference lies in how they receive and process content. Additionally caching is not implemented for response class but for template view object cache is implemented.

Response Class Example

The Response class allows you to handle any type of response rendering without additional processing, making it particularly useful for APIs that need to return JSON responses, downloadable content, and more.

// /app/Controllers/BookController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;

#[Error('api', onError: [ViewErrors::class, 'onApiError'])]
class BookController extends BaseController 
{
    #[Route('/api/books', methods: ['POST'])]
    public function apiListBooks(): int 
    {
        $books = [
            ['id' => 100, 'name' => 'Basic Programming'],
            ['id' => 1001, 'name' => 'Advanced Programming']
        ];

        return response(200)->json($books);
    }
}

In above example, when a POST request is sent to https://example.com/api/books, it will output a JSON response containing the list of books.

Application View Example

The View object is designed to load and render templates stored in the /resources/views directory. Supported template file extensions include: - .tpl: For the Smarty template engine - .twg: For the Twig template engine - .php: For standard PHP templates

When you pass the template file name without the extension, the View object automatically loads the template, processes the content, and allows you to pass optional metadata during rendering.

Template File Example

// /resources/views/books.php
<!DOCTYPE html>
<html lang="en"> 
<head>
    <title><?php $this->_title;?></title>
</head>
<body>
    <h1>My Book Website</h1>
    <ul>
        <?php foreach ($this->_books as $book): ?>
            <li>[<?= $book['id']; ?>] <?= $book['name']; ?></li>
        <?php endforeach; ?>
    </ul>
</body>
</html>

Books Template Controller Handler Example

// /app/Controllers/BookController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseViewController;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;

#[Error(onError: [ViewErrors::class, 'onWebError'])]
class BookController extends BaseViewController 
{
    #[Route('/books', methods: ['GET'])]
    public function webShowBooks(): int 
    {
        // Assume loading books from a database.
        $books = [
            ['id' => 100, 'name' => 'Basic Programming'],
            ['id' => 1001, 'name' => 'Advanced Programming']
        ];

        return $this->view('books', [
            'books' => $books
        ]);
    }
}

In this example, when a GET request is sent to https://example.com/books, it displays an HTML page containing the list of books.

Retrieving and Using View Content

There may be cases where you want to generate a template's output without displaying it directly to the user, such as when sending an email with the rendered content.

Here's how you can achieve this:

// /app/Controllers/BookController.php
<?php
namespace App\Controllers;

use Luminova\Base\BaseController;
use Luminova\Email\Mailer;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;

#[Error(onError: [ViewErrors::class, 'onWebError'])]
class BookController extends BaseController
{
    #[Route('/books/send', methods: ['GET'])]
    public function sendShowBooks(string $email): int
    {
        $books = [
            ['id' => 100, 'name' => 'Basic Programming'],
            ['id' => 1001, 'name' => 'Advanced Programming']
        ];

        // Generate the view content without rendering it
        $content = $this->respond('books', [
            'books' => $books
        ]);

        // Send the generated content as an email
        Mailer::to($email)->send($content);

        // Redirect the user after sending the email
        $this->app->redirect('thank-you');
        return STATUS_SUCCESS;
    }
}

How It Works

Generating Content: The `respond` method is used to process the template and return the rendered content as a string. This allows you to use the content in other contexts, such as sending it via email.
Sending the Email: The content is passed to the `Mailer::to()->send()` method, which sends the email to the specified recipient.
Redirecting the User: After the email is sent, the user is redirected to a "thank you" page or any other desired location.

This approach is useful when you need to use the output of a template for purposes other than direct display, such as generating emails, saving content to a file, or performing other custom actions.

Custom View Headers

Luminova automatically handles the basic headers for your template output, but there may be times when you want to include additional headers to be sent along with your template.

Here's how you can do it:

<?php 
namespace App\Controllers;

use Luminova\Base\BaseViewController;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;

#[Error(onError: [ViewErrors::class, 'onWebError'])]
class MyController extends BaseViewController 
{
    #[Route('/books', methods: ['GET'])]
    public function webShowBooks(): int 
    {
        // Set multiple headers at once using an array
        $this->app->headers([
            'Content-Type' => 'text/html; charset=utf-8',
            'X-Custom-Header' => 'CustomValue'
        ]);
        
        // Or set a single header using key-value pairs
        $this->app->header('Content-Type', 'text/html; charset=utf-8');
        
        return $this->view('books');
    }
}

How It Works

Multiple Headers: You can pass an associative array to the `headers` method, where the keys represent the header names and the values represent their corresponding values. This allows you to set multiple headers at once.
Single Header: If you only need to set a single header, you can use the `header` method, providing the header name and value as arguments.

This flexibility ensures that you can customize the headers sent with your views to match your specific needs, whether it's content type, caching controls, or custom headers.

Application View Caching Examples

The template view in Luminova allows you to cache content, serving a cached version of the page upon revisits. Caching can be implemented either automatically or manually to learn more about view caching read documentation.

To enable page view caching, update your environment variables as follows:

Enable page caching by setting `page.caching` to `true`.
Set the cache expiration duration using `page.cache.expiry`. To cache content indefinitely, set this value to `0`, which defaults to a 5-year duration. You can manually set a longer duration if you prefer a custom expiration period.
Optionally, set `page.caching.immutable` to `true` to add the `immutable` directive to your cache control headers for content that should never expire.

Automatic Caching

Automatic caching requires no additional implementation after enabling the caching feature and setting the desired cache expiration and controls.

Manual Caching with Auto Renewal

This method allows you to render cached content if it is still valid. The callback function will only be executed if the cache does not exist or has expired.

<?php 
namespace App\Controllers;

use Luminova\Base\BaseViewController;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;

#[Error(onError: [ViewErrors::class, 'onWebError'])]
class MyController extends BaseViewController 
{
    #[Route('/books', methods: ['GET'])]
    public function webShowBooks(): int 
    {
        // The first argument is the type of view content.
        $this->app->onExpired('html', function() {
            $books = [
                ['id' => 100, 'name' => 'Basic Programming'],
                ['id' => 1001, 'name' => 'Advanced Programming']
            ];

            return $this->view('books', [
                'books' => $books
            ]);
        });
    }
}

Manual Caching and Renewal

This approach uses a traditional if-else check to first verify if the cache has expired. If the cache is still valid, the existing content is rendered when you call the reuse method. If the cache has expired, new content is generated to refresh the content.

<?php 
namespace App\Controllers;

use Luminova\Base\BaseViewController;
use Luminova\Attributes\Route;
use Luminova\Attributes\Error;
use App\Controllers\Errors\ViewErrors;
use Luminova\Core\CoreApplication;

#[Error(onError: [ViewErrors::class, 'onWebError'])]
class MyController extends BaseViewController 
{
    #[Route('/books', methods: ['GET'])]
    public function webShowBooks(): int 
    {
        // Set an expiration time (in seconds) or leave blank/null to use the default expiration.
        $this->app->cache(3600);

        if ($this->app->expired()) {
            $books = [
                ['id' => 100, 'name' => 'Basic Programming'],
                ['id' => 1001, 'name' => 'Advanced Programming']
            ];

            return $this->view('books', [
                'books' => $books
            ]);
        }

        return $this->app->reuse();
    }
}

In these examples, when a GET request is sent to https://example.com/books, the application checks for cached content and serves it accordingly, ensuring efficient use of resources and faster response times.

Serving Static Content

Luminova supports serving static content, meaning that when content is cached, your controller class or method will not be invoked upon page visits. Instead, the cached version is served, enhancing performance.

To enable static cache serving, specify the list of supported static content types in your environment configuration file (.env).

Example:

In the following example, we specify the supported view content types as HTML and JSON. This configuration instructs the framework to process any URLs ending with these extensions. If a corresponding view exists, it will be served.

page.caching.statics = html|json

In this case, if a user visits https://example.com/books.html, the cached content will be served if available; otherwise, it will be cached. Conversely, since there is no view matching .json, visiting https://example.com/books.json will trigger a 404 error.

View Caching Exclusion and Inclusion

While caching is enabled globally, you can exclude certain views from being cached or specify a list of views that can be cached. This can be accomplished in your application class's onCreate or __construct method, or within your controller class's onCreate or __construct method.

Exclusion Example

To exclude views from caching, define them as follows:

<?php 
namespace App;

use Luminova\Core\CoreApplication;

class Application extends CoreApplication
{
	protected function onCreate(): void 
	{
		$this->noCaching([
			'edit_book',
			'book_payment',
			'book_cart'
		]);
	}
}

Inclusion Example

If you have many views but only want to cache one, you can use the cacheOnly method to specify just that view, avoiding the need to list all others:

<?php 
namespace App;

use Luminova\Core\CoreApplication;

class Application extends CoreApplication
{
	protected function onCreate(): void 
	{
		// Accepts a string or an array of views.
		$this->cacheOnly('books');
	}
}

View Directory Structure

Organizing content in a framework is crucial for easy access and management. Luminova provides a simple and effective way to maintain a clean and organized structure for your view templates based on URL prefixes.

Scenario

Imagine you have a website with the following URL patterns:

`https://example.com/api/*` (API endpoints)
`https://example.com/admin/*` (Admin interface)
`https://example.com/*` (Main website)

Placing all templates directly under the resources/views/ directory could become unmanageable as your project grows. To maintain orderliness, you can organize your views into separate directories based on URL prefixes.

Example

You can create dedicated controller classes for each URL prefix, such as ApiController for API requests, AdminController for the admin interface, and WebController for the main website.

Within each controller's onCreate or __construct method, you can specify the base directory where the corresponding template files are located under the /resources/views/ root directory.

Here's how you can set it up:

// /app/Controllers/WebController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;

class WebController extends BaseController
{
	protected function onCreate(): void 
	{
		// No need to change the directory; it uses the default root directory.
	}
}

// /app/Controllers/ApiController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;

class ApiController extends BaseController
{
	protected function onCreate(): void 
	{
	 	// Organize API views in /resources/views/apis/
		$this->setFolder('apis');
	}
}

// /app/Controllers/AdminController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;

class AdminController extends BaseController
{
	protected function onCreate(): void 
	{
		// Organize admin views in /resources/views/admins/
		$this->setFolder('admins'); 
	}
}

Output Minification

In Luminova, you can easily enable output minification when rendering HTML templates using the template view object. This feature automatically minifies your web page content by removing inline comments and newlines, resulting in a more compact and faster-loading page.

When you visit some websites and use Ctrl + U to view the HTML source, you may notice that it's not easily readable due to such minification. Luminova allows you to achieve this in your project by enabling the page.minification environment variable in your .env file. Simply set it to true to minify your template output.

Minification Options

Minifying all content is generally beneficial, but it can be problematic for websites that display sample code within HTML <pre><code> blocks. Minification can make the code within these blocks unreadable by removing newlines, which also prevents JavaScript syntax highlighters from functioning correctly.

Luminova offers a solution to this issue by allowing you to exclude code blocks from minification while still ensuring the rest of your page content is properly minified. Here's how you can do it:

Example:

In your application controller's onCreate or __construct method, you can call the codeblock method and pass false as the first parameter to exclude code blocks from minification. You can also pass true as the second parameter to include a copy button alongside the code block, similar to what's found on the Luminova documentation website.

// /app/Controllers/AdminController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;

class AdminController extends BaseController
{
	protected function onCreate(): void 
	{
		$this->codeblock(
			false,  // Exclude code blocks from minification
			true    // Include a copy button with the code block
		); 
	}
}

By using this approach, you can maintain both the readability of your code samples and the overall performance benefits of minified content.

Object Exportation in Luminova

Luminova provides two rendering modes for templates, which can be configured in your application's template configuration class located at /app/Config/Template.php. These modes allow you to choose your preferred coding style and determine how templates interact with application objects.

When the template rendering mode is set to isolation, the view processing is entirely isolated, meaning you cannot access application class objects using the $this keyword. Instead, a custom keyword $self is provided to access properties defined in the application's class scope.

However, to still access protected or public properties defined in the application class, you need to export them using the export method. This method allows you to make specific objects or class instances available within the isolated template context.

Example

// /app/Controllers/AdminController.php
<?php 
namespace App\Controllers;

use Luminova\Base\BaseController;
use App\Models\Users;
use App\Utils\Foo;
use App\Utils\Bar;
use App\Utils\Baz;

class AdminController extends BaseController
{
	protected Users $users;

	public function __construct() 
	{
		// Initialize and export an instance of the Users class
		$this->users = new Users();
		$this->export($this->users, 'users');

		// Export a class that has static methods without initialization
		$this->export(Foo::class, null, false);

		// Export a class and initialize it upon export
		$this->export(Bar::class, null, true);

		// Export a class, initialize it, and assign it a different name (alias) for use in templates
		$this->export(Baz::class, 'ClassBaz', true);
	}
}

How It Works

Exporting Instances: When you initialize an object, such as the `Users` class, you can export it to make it accessible within the isolated template context. In this case, the object is assigned the name `users` for use within the template.
Static Class Export: For classes like `Foo`, which only contain static methods and don't require initialization, you can export them without creating an instance. This allows the static methods to be accessed directly in the template.
Exporting with Initialization: For classes that need to be initialized (e.g., `Bar` and `Baz`), you can specify this during export. Additionally, you can assign a different name (alias) to the exported object for use within the template.

Use Case

This approach is particularly useful in complex applications where templates need access to specific objects or classes while maintaining a strict separation between the view and controller logic. By exporting the necessary objects or classes, you ensure that your templates have the required context and data to render correctly, even in isolated mode.

Details

PHP Luminova Framework

Endpoint Badge

About Luminova!

Luminova is a PHP framework built for speed and efficiency, designed to enhance your existing coding skills. At Luminova, we prioritize performance by offering feature customization through the env file. This ensures the framework includes only what's needed for your project, based on the features you enable. This approach allows you to enable or disable features as well as customizing your preferred template rendering mode and coding style.

Luminova, provide access to the template View object within the view files, allowing you to call template methods and properties using $this keyword within template files. This can be disabled if you prefer your views to be rendered in isolation, disabling it will allow you to access exported application classes using custom keyword $self.

Ready to light up your projects? Dive into our official documentation. For more tips, tricks, and some coding fun, check out our YouTube channel.

Composer Installation

Install luminova via Composer.

composer create-project luminovang/luminova my-project

Start Development Server

To start the PHP development server, run the following NovaKit command.

php novakit server

Sitemap Generator

To generate your website sitemap use the below NovaKit command.

php novakit generate:sitemap

To learn more about NovaKit commands read the novakit documentation.

Routing

Luminova support flexible routing implementation using Attributes or Router methods.

Define your route using PHP8 attributes:*

#[Route('/', methods: ['GET'])]
public function index(): int 
{
    return $this->view('index');
}

Or define your route using code-based routing:

<?php 
$router->get('/', 'YourController::index');

What's There For Me?

Here we can brief you on the basic features you can expect in Luminova. There's a lot more than what is written here. As Linus Torvalds said, "Talk is cheap. Show me the code."

Database Builder: A powerful Object Relational Mapping (ORM) tool that organizes CRUD operations and simplifies database interactions.
MVC & HMVC Architecture: Adheres to the Model-View-Controller and Hierarchical Model-View-Controller implementation.
Flexible HTTP Routing: Dynamic and fast routing implementation with a clear separation of concerns.
Templating: Optimized native PHP templating with additional inheritance and caching features. You can also use `Twig` or `Smarty` template engines.
Error Handling: Comprehensive error handling ensures that no errors go unnoticed, including non-fatal inline errors.
Session Management: Easily manage user login sessions without additional implementation.
CLI Routing: Dynamic routing for CLI implementations similar to HTTP routing methods.
Cloud Storage: Supports various cloud storage solutions like AWS, Azure, Google Cloud, and more.
File Management: Deliver files to the browser from any location with temporary or permanent URLs to access private files.
Sitemap Generator: Generate website sitemaps using the `NovaKit` command.
Schema Object: Support for generating schema objects for website pages.
Command Line Tool: Full support for implementing CLI tools, with everything you need available.
AI Models: Integrate or extend AI features into your application.
Database: A flexible database system that supports instant failover to a backup database without user interruption.
Security: Various security implementations to secure your application and user information.
Request Handling: Secure handling of incoming and outgoing HTTP requests.
Email: Send emails anywhere, with support for sending entire view content as the email body.
Translation: Create translations for your application using our translation class.
Encryption: Support for different encryption handlers and methods.
Services: Define classes that can be shared and discovered anywhere in your codebase, with support for serialization and class object caching.

Quick Tips

Q: My session works on the development server but not on the production server. - A: In production, update the $sessionDomain in /app/Config/Session.php to your actual production domain. A quick fix is to use '.' . APP_HOST. Also, don't forget to update the Cookie.php configuration accordingly.

Q: My CSS and images are broken on the production server. - A: Make sure you set the app.environment.mood key to production in your environment file when deploying to production. This small step ensures your assets are served correctly.

Something Missing?

Your feedback is highly appreciated! Drop us a line at peter@luminova.ng. Let us know what we can add to enhance your experience with Luminova. You can also recommend tutorials for our YouTube channel to help you understand and use Luminova better.

Most importantly, don't forget to rate Luminova on GitHub. Your rating is like fuel, helping to illuminate our motivation to add more features and make Luminova even better known and more powerful.

Luinova Website

Open in a separate window

Videos (3)

Files (108)

File	Role	Description
`app` (1 file, 4 directories)
`bootstrap` (3 files)
`docs` (2 files)
`public` (4 files, 1 directory)
`resources` (1 directory)
`routes` (3 files)
`samples` (1 file)
`system` (1 file, 3 directories)
`.env`	Data	Auxiliary data
`composer.json`	Data	Auxiliary data
`LICENSE`	Lic.	License text
`novakit`	Appl.	Luminova CLI Tool
`phpstan.includes.php`	Aux.	Auxiliary script
`phpstan.neon`	Data	Auxiliary data
`phpunit.xml`	Data	Auxiliary data
`README.md`	Doc.	Documentation
`rector.php`	Class	Class source

File	Role	Description
`Config` (18 files, 1 directory)
`Controllers` (3 files, 1 directory)
`Languages` (2 files)
`Utils` (2 files)
`Application.php`	Class	Class source

File	Role	Description
`Templates` (2 directories)
`AI.php`	Class	Class source
`Apis.php`	Class	Class source
`Browser.php`	Class	Class source
`Cookie.php`	Class	Class source
`Cron.php`	Class	Class source
`Database.php`	Class	Class source
`Encryption.php`	Class	Class source
`Files.php`	Class	Class source
`IPConfig.php`	Class	Class source
`Modules.php`	Aux.	Configuration script
`Preference.php`	Class	Class source
`Schema.php`	Aux.	Configuration script
`Security.php`	Class	Class source
`Services.php`	Class	Class source
`Session.php`	Class	Class source
`Sitemap.php`	Class	Class source
`Storage.php`	Aux.	Configuration script
`Template.php`	Class	Class source

File	Role	Description
`Classes.php`	Class	Class source
`Modifiers.php`	Class	Class source

File	Role	Description
`Extensions.php`	Class	Class source
`Filters.php`	Class	Class source
`Functions.php`	Class	Class source
`Globals.php`	Class	Class source
`NodeVisitors.php`	Class	Class source
`Operators.php`	Class	Class source
`Rot13Provider.php`	Class	Class source
`Tests.php`	Class	Class source
`TokenParsers.php`	Class	Class source

File	Role	Description
`Errors` (1 file)
`DemoCommand.php`	Example	Class source
`DemoRequest.php`	Class	Class source
`Welcome.php`	Class	Class source

File	Role	Description
`App.en.php`	Aux.	Configuration script
`App.fr.php`	Aux.	Configuration script

File	Role	Description
`constants.php`	Example	Example script
`features.php`	Aux.	Auxiliary script
`functions.php`	Class	Class source

File	Role	Description
`assets` (1 directory)
`.htaccess`	Data	Auxiliary data
`favicon.png`	Icon	Icon image
`index.php`	Class	Class source
`robots.txt`	Doc.	Documentation

File	Role	Description
`system_errors` (10 files)
`404.php`	Example	Example script
`index.php`	Aux.	Auxiliary script
`index.tpl`	Data	Auxiliary data
`index.twig`	Data	Auxiliary data

File	Role	Description
`api.php`	Example	Example script
`cli.php`	Aux.	Auxiliary script
`web.php`	Example	Example script

File	Role	Description
`Composer` (3 files)
`Debugger` (3 files)
`plugins` (1 file, 2 directories)
`Boot.php`	Class	Class source

File	Role	Description
`BaseComposer.php`	Class	Class source
`Builder.php`	Class	Class source
`Updater.php`	Class	Class source

File	Role	Description
`Performance.php`	Class	Class source
`PHPStanRules.php`	Class	Class source
`Tracer.php`	Class	Class source

File	Role	Description
`composer` (11 files)
`psr` (1 directory)
`autoload.php`	Aux.	Auxiliary script

File	Role	Description
`autoload_classmap.php`	Aux.	Auxiliary script
`autoload_namespaces.php`	Aux.	Auxiliary script
`autoload_psr4.php`	Aux.	Auxiliary script
`autoload_real.php`	Class	Class source
`autoload_static.php`	Class	Class source
`ClassLoader.php`	Class	Class source
`installed.json`	Data	Auxiliary data
`installed.php`	Aux.	Auxiliary script
`InstalledVersions.php`	Class	Class source
`LICENSE`	Lic.	License text
`platform_check.php`	Aux.	Auxiliary script

File	Role	Description
`Test` (3 files)
`AbstractLogger.php`	Class	Class source
`InvalidArgumentException.php`	Class	Class source
`LoggerAwareInterface.php`	Class	Class source
`LoggerAwareTrait.php`	Class	Class source
`LoggerInterface.php`	Class	Class source
`LoggerTrait.php`	Class	Class source
`LogLevel.php`	Class	Class source
`NullLogger.php`	Class	Class source

File	Role	Description
`DummyTest.php`	Class	Class source
`LoggerInterfaceTest.php`	Class	Class source
`TestLogger.php`	Class	Class source

	luminova-2024-09-03.zip
	luminova-2024-09-03.tar.gz
	Install with Composer