README

# Luna PHP Framework Skeleton A pre-configured **starter template** to build your application with the modern, lightweight, and extensible **Luna PHP Framework**. Designed to simplify development, ensuring scalability, **PSR compliance**, and seamless integration of the Luna Framework. Built for **PHP 8.2**, leveraging the full power of modern PHP.

[[TOC]]

ℹ️ About the Skeleton

The Luna Skeleton is designed to provide a smooth starting point for developing applications with the Luna Framework. It includes all essential configuration and folder structures you need to kickstart your next PHP project.

This project is written in PHP 8.2+ and uses Composer for dependency management.

• Complete integration with Luna Framework.
• Adheres to Modern PHP Standards.
• Extensible and modular design to fit a variety of use cases.

Learn more about the Luna Framework by visiting the official Luna Wiki.

Key Features

• Simplified Setup: Pre-configured with the Luna Framework, helping you save time on boilerplate.
• PSR-4 Autoloading: Fully compliant with modern PHP standards, ensuring better modularity.
• Composer Compatibility: Easily manage dependencies using the composer.json file provided.
• Scalable and Modular: Straightforward structure to grow your project efficiently.

🗂️ Directory Structure

The skeleton follows a clean and modular architecture:

📂 skeleton/
 ├── 📂 config/          # Configuration files (modular & extensible)
 ├── 📂 src/             # Application core
 ├── 📂 var/             # Cache, logs, and generated files
 ├── 📂 vendor/          # Composer packages
 ├── 📄 .gitignore       # Git exclusions
 ├── 📄 composer.json    # Composer metadata
 ├── 📄 composer.lock    # Locked dependencies version
 ├── 📄 LICENSE          # License information
 ├── 📄 luna.lock        # Luna lock management file
 └── 📄 README.md        # Project documentation

🔧 Dependencies

This skeleton project utilizes the Luna PHP Framework as the core library. Dependencies required include:

• Luna Framework: Core framework for modern PHP applications. (MIT License)
• Developer tools for testing:
  • PHPUnit

Refer to the composer.json file for additional details.

⚙️ Setup and Installation

To get started with this skeleton:

Step 1: Create the Project

First, ensure you have Composer installed in your system.
The, creates a new project using the following command:

composer create-project shiros/luna-skeleton <your-project-name>

You'll need PHP 8.2+ installed on your system.

Step 2: Install Dependencies

Navigate to the root project folder and install the required dependencies with Composer:

composer install

This will ensure all dependencies are fetched, including shiros/luna and PHPUnit for testing purposes.

Step 3: Start Developing

Once setup is complete, you can start developing your application by extending the provided core. For adding additional configuration, utilize /config and define custom modules.

🚀 Usage Example

Refer to the official documentation for advanced examples and further details.

Registering kernel

The Luna Framework kernel is easy to load. Here's an example on how to do it:

use Luna\Component\Lock\LunaLock;
use Luna\Kernel;
use Luna\KernelInterface;

try {
    /**
     * Create Luna kernel options.
     * Options let you customize the kernel.
     * 
     * - KernelInterface::OPT_ENVIRONMENT: Allows specifying a custom environment file / instance.
     * - KernelInterface::OPT_LOCK       : Allows specifying a custom lock file.
     * - KernelInterface::OPT_STANDALONE : Deactivate Luna's modules loading.
     */
    $options = [
        // Environment 
        KernelInterface::OPT_ENVIRONMENT => '/path/to/env_file',
        KernelInterface::OPT_ENVIRONMENT => [ 'key1' => 'value1' ],
                  
        // Lock 
        KernelInterface::OPT_ENVIRONMENT => '/path/to/lock_file.lock',
        KernelInterface::OPT_ENVIRONMENT => new LunaLock(),
        
        // Mode
        KernelInterface::OPT_STANDALONE => true, // By default, the standalone mode isn't enabled.
    ];

    /**
     * Create a Luna Kernel instance.
     * You can pass options to customize the kernel.
     */
    $kernel = new Kernel();
    // $kernel = new Kernel($options);
    
    /**
     * Starts the kernel as a Web handler.
     * You could do that only if the module 'shiros/web' is installed.
     */
    $kernel->start();
} catch (Throwable $e) {
    echo 'Error: ' . $e->getMessage();
}

Handling Configuration Files

Configuration management in Luna is straightforward and supports multiple formats (e.g., PHP, JSON, YAML). Here's an example on how to use it:

use Luna\Config\Config;

try {
    // Create a config instance
    $config = new Config();
    
    /**
     * Load your config folder.
     * Loads 'config/app.php', 'config/services.php', etc.
     */
    $config->load(
        path : __DIR__ . '/config', 
        files: ['app', 'services']  // Target files. Configuration files to load
    );

    // Show the configuration
    var_dump($config->all());
} catch (Throwable $e) {
    echo 'Error: ' . $e->getMessage();
}

📃 License

This project is licensed under the MIT License, allowing you to use and modify this project freely.
See the LICENSE file for more details.

👨‍💻 Authors and Contributors

This project was created and is maintained by Alexandre Caillot (Shiroe_sama), with contributions from the community.

Authors

• Alexandre Caillot (Shiroe_sama)

Contributors

We thank the following contributors for making this project better:

• Maxime Mazet (ElBidouilleur)