PHP Classes

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!
  Info   Documentation   Demos   Videos   View files Files   Install with Composer Install with Composer   Download Download   Reputation   Support forum   Blog    
Last Updated Ratings Unique User Downloads Download Rankings
2024-09-21 (4 days ago) RSS 2.0 feedNot enough user ratingsTotal: 38 This week: 7All time: 10,933 This week: 6Up
Version License PHP version Categories
luminova 3.2.12MIT/X Consortium ...8.0Tools, Libraries, Templates, Console, C..., D..., P...
Description 

Author

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.

Picture of Ujah Chigozie peter
  Performance   Level  
Name: Ujah Chigozie peter <contact>
Classes: 28 packages by
Country: Nigeria Nigeria
Innovation award
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:

  1. Enable page caching by setting `page.caching` to `true`.
  2. 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.
  3. 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

Author PHP 8.0+ Source Code Latest Version Framework Source Code Framework Latest Version Software License Total Downloads Endpoint Badge

Local Image

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 WebsiteExternal page  

Open in a separate window

Videos (3)  
  • Luminova Installation Guide
  • PHP Luminova Framwork User Signup & Login Example
  • PHP Luminova Framwork With Symfony Twig Template
  Files folder image Files (110)  
File Role Description
Files folder imageapp (1 file, 4 directories)
Files folder imagebootstrap (3 files)
Files folder imagedocs (2 files)
Files folder imagepublic (4 files, 1 directory)
Files folder imageresources (1 directory)
Files folder imageroutes (3 files)
Files folder imagesamples (1 file)
Files folder imagesystem (1 file, 3 directories)
Accessible without login Plain text file .env Data Auxiliary data
Accessible without login Plain text file .php-cs-fixer.php Example Example script
Accessible without login Plain text file composer.json Data Auxiliary data
Accessible without login Plain text file LICENSE Lic. License text
Accessible without login Plain text file novakit Appl. Luminova CLI Tool
Accessible without login Plain text file phpstan.includes.php Aux. Auxiliary script
Accessible without login Plain text file phpstan.neon Data Auxiliary data
Accessible without login Plain text file phpunit.xml Data Auxiliary data
Accessible without login Plain text file README.md Doc. Documentation
Plain text file rector.php Class Class source

  Files folder image Files (110)  /  app  
File Role Description
Files folder imageConfig (19 files, 1 directory)
Files folder imageControllers (3 directories)
Files folder imageLanguages (2 files)
Files folder imageUtils (2 files)
  Plain text file Application.php Class Class source

  Files folder image Files (110)  /  app  /  Config  
File Role Description
Files folder imageTemplates (2 directories)
  Plain text file AI.php Class Class source
  Plain text file Apis.php Class Class source
  Plain text file Browser.php Class Class source
  Plain text file ContentSecurityPolicy.php Class Class source
  Plain text file Cookie.php Class Class source
  Plain text file Cron.php Class Class source
  Plain text file Database.php Class Class source
  Plain text file Encryption.php Class Class source
  Plain text file Files.php Class Class source
  Plain text file IPConfig.php Class Class source
  Accessible without login Plain text file Modules.php Aux. Configuration script
  Plain text file Preference.php Class Class source
  Accessible without login Plain text file Schema.php Aux. Configuration script
  Plain text file Security.php Class Class source
  Plain text file Services.php Class Class source
  Plain text file Session.php Class Class source
  Plain text file Sitemap.php Class Class source
  Accessible without login Plain text file Storage.php Aux. Configuration script
  Plain text file Template.php Class Class source

  Files folder image Files (110)  /  app  /  Config  /  Templates  
File Role Description
Files folder imageSmarty (2 files)
Files folder imageTwig (9 files)

  Files folder image Files (110)  /  app  /  Config  /  Templates  /  Smarty  
File Role Description
  Plain text file Classes.php Class Class source
  Plain text file Modifiers.php Class Class source

  Files folder image Files (110)  /  app  /  Config  /  Templates  /  Twig  
File Role Description
  Plain text file Extensions.php Class Class source
  Plain text file Filters.php Class Class source
  Plain text file Functions.php Class Class source
  Plain text file Globals.php Class Class source
  Plain text file NodeVisitors.php Class Class source
  Plain text file Operators.php Class Class source
  Plain text file Rot13Provider.php Class Class source
  Plain text file Tests.php Class Class source
  Plain text file TokenParsers.php Class Class source

  Files folder image Files (110)  /  app  /  Controllers  
File Role Description
Files folder imageCli (1 file)
Files folder imageErrors (1 file)
Files folder imageHttp (2 files)

  Files folder image Files (110)  /  app  /  Controllers  /  Cli  
File Role Description
  Plain text file DemoCommand.php Class Class source

  Files folder image Files (110)  /  app  /  Controllers  /  Errors  
File Role Description
  Plain text file ViewErrors.php Class Class source

  Files folder image Files (110)  /  app  /  Controllers  /  Http  
File Role Description
  Plain text file DemoRequest.php Class Class source
  Plain text file Welcome.php Class Class source

  Files folder image Files (110)  /  app  /  Languages  
File Role Description
  Accessible without login Plain text file App.en.php Aux. Configuration script
  Accessible without login Plain text file App.fr.php Aux. Configuration script

  Files folder image Files (110)  /  app  /  Utils  
File Role Description
  Plain text file Functions.php Class Class source
  Accessible without login Plain text file Global.php Aux. Configuration script

  Files folder image Files (110)  /  bootstrap  
File Role Description
  Accessible without login Plain text file constants.php Example Example script
  Accessible without login Plain text file features.php Aux. Auxiliary script
  Plain text file functions.php Class Class source

  Files folder image Files (110)  /  docs  
File Role Description
  Accessible without login Plain text file basic.md Doc. Documentation
  Accessible without login Plain text file logo.svg Data Auxiliary data

  Files folder image Files (110)  /  public  
File Role Description
Files folder imageassets (1 directory)
  Accessible without login Plain text file .htaccess Data Auxiliary data
  Accessible without login Image file favicon.png Icon Icon image
  Plain text file index.php Class Class source
  Accessible without login Plain text file robots.txt Doc. Documentation

  Files folder image Files (110)  /  public  /  assets  
File Role Description
Files folder imagecss (1 file)

  Files folder image Files (110)  /  public  /  assets  /  css  
File Role Description
  Accessible without login Plain text file app.css Data Auxiliary data

  Files folder image Files (110)  /  resources  
File Role Description
Files folder imageviews (4 files, 1 directory)

  Files folder image Files (110)  /  resources  /  views  
File Role Description
Files folder imagesystem_errors (10 files)
  Accessible without login Plain text file 404.php Example Example script
  Accessible without login Plain text file index.php Aux. Auxiliary script
  Accessible without login Plain text file index.tpl Data Auxiliary data
  Accessible without login Plain text file index.twig Data Auxiliary data

  Files folder image Files (110)  /  resources  /  views  /  system_errors  
File Role Description
  Accessible without login Plain text file 404.php Aux. Auxiliary script
  Accessible without login Plain text file api.php Example Example script
  Plain text file cli.php Class Class source
  Accessible without login Plain text file debug.css Data Auxiliary data
  Accessible without login Plain text file errors.php Example Example script
  Accessible without login Plain text file info.php Aux. Configuration script
  Accessible without login Plain text file maintenance.css Data Auxiliary data
  Accessible without login Plain text file maintenance.php Aux. Auxiliary script
  Accessible without login Plain text file tracer.php Example Example script
  Accessible without login Plain text file view.error.php Aux. Auxiliary script

  Files folder image Files (110)  /  routes  
File Role Description
  Accessible without login Plain text file api.php Example Example script
  Accessible without login Plain text file cli.php Aux. Auxiliary script
  Accessible without login Plain text file web.php Example Example script

  Files folder image Files (110)  /  samples  
File Role Description
  Accessible without login Plain text file index.php Example Sample index

  Files folder image Files (110)  /  system  
File Role Description
Files folder imageComposer (3 files)
Files folder imageDebugger (3 files)
Files folder imageplugins (1 file, 2 directories)
  Plain text file Boot.php Class Class source

  Files folder image Files (110)  /  system  /  Composer  
File Role Description
  Plain text file BaseComposer.php Class Class source
  Plain text file Builder.php Class Class source
  Plain text file Updater.php Class Class source

  Files folder image Files (110)  /  system  /  Debugger  
File Role Description
  Plain text file Performance.php Class Class source
  Plain text file PHPStanRules.php Class Class source
  Plain text file Tracer.php Class Class source

  Files folder image Files (110)  /  system  /  plugins  
File Role Description
Files folder imagecomposer (11 files)
Files folder imagepsr (1 directory)
  Accessible without login Plain text file autoload.php Aux. Auxiliary script

  Files folder image Files (110)  /  system  /  plugins  /  composer  
File Role Description
  Accessible without login Plain text file autoload_classmap.php Aux. Auxiliary script
  Accessible without login Plain text file autoload_namespaces.php Aux. Auxiliary script
  Accessible without login Plain text file autoload_psr4.php Aux. Auxiliary script
  Plain text file autoload_real.php Class Class source
  Plain text file autoload_static.php Class Class source
  Plain text file ClassLoader.php Class Class source
  Accessible without login Plain text file installed.json Data Auxiliary data
  Accessible without login Plain text file installed.php Aux. Auxiliary script
  Plain text file InstalledVersions.php Class Class source
  Accessible without login Plain text file LICENSE Lic. License text
  Accessible without login Plain text file platform_check.php Aux. Auxiliary script

  Files folder image Files (110)  /  system  /  plugins  /  psr  
File Role Description
Files folder imagelog (3 files, 1 directory)

  Files folder image Files (110)  /  system  /  plugins  /  psr  /  log  
File Role Description
Files folder imagePsr (1 directory)
  Accessible without login Plain text file composer.json Data Auxiliary data
  Accessible without login Plain text file LICENSE Lic. License text
  Plain text file README.md Class Class source

  Files folder image Files (110)  /  system  /  plugins  /  psr  /  log  /  Psr  
File Role Description
Files folder imageLog (8 files, 1 directory)

  Files folder image Files (110)  /  system  /  plugins  /  psr  /  log  /  Psr  /  Log  
File Role Description
Files folder imageTest (3 files)
  Plain text file AbstractLogger.php Class Class source
  Plain text file InvalidArgumentException.php Class Class source
  Plain text file LoggerAwareInterface.php Class Class source
  Plain text file LoggerAwareTrait.php Class Class source
  Plain text file LoggerInterface.php Class Class source
  Plain text file LoggerTrait.php Class Class source
  Plain text file LogLevel.php Class Class source
  Plain text file NullLogger.php Class Class source

  Files folder image Files (110)  /  system  /  plugins  /  psr  /  log  /  Psr  /  Log  /  Test  
File Role Description
  Plain text file DummyTest.php Class Class source
  Plain text file LoggerInterfaceTest.php Class Class source
  Plain text file TestLogger.php Class Class source

The PHP Classes site has supported package installation using the Composer tool since 2013, as you may verify by reading this instructions page.
Install with Composer Install with Composer
Downloadluminova-2024-09-21.zip 158KB
Downloadluminova-2024-09-21.tar.gz
Install with ComposerInstall with Composer
Needed packages  
Class DownloadWhy it is needed Dependency
Luminova Framework Dependency Download .zip .tar.gz The Luminova framework source code and modules Required
 Version Control Unique User Downloads Download Rankings  
 100%
Total:38
This week:7
All time:10,933
This week:6Up