Orbis: The Magic of Abstraction in PHP

Have you ever wondered how to simplify complex functionalities in PHP in an elegant and reusable way? We present Orbis, a revolutionary tool that transforms the way we manage instances and abstractions in PHP.

What is Orbis? 🤔

Orbis is a powerful class that acts as a global instance manager, allowing you to abstract complex functionalities into simple, reusable components. Imagine being able to encapsulate all routing, configuration, and state management logic in a single line of code!

The Magic Behind Orbis ✨

To understand the true power of Orbis, let's look at a real example from the Lithe framework:

function get(string $path, callable|array ...$handler): void {

    $caller = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];

    $key = strtolower($caller['file']);



    $router = Orbis::instance($key);

    if (!$router instanceof Router) {

        throw new Exception("Invalid router instance: Router not found");

    }



    $router->get($path, ...$handler);

}

This seemingly simple code hides an incredibly powerful functionality. Orbis allows:

1. Each file to have its own router.


2. Routes to be automatically managed and organized.


3. No conflicts between different parts of the application.

A Practical Example That Will Surprise You 🚀

Let's create a smart cache system using Orbis:

class SmartCache {

    private array $storage = [];

    private array $analytics = [];



    public function set(string $key, mixed $value, int $ttl = 3600): void {

        $this->storage[$key] = [

            'value' => $value,

            'expires' => time() + $ttl,

            'hits' => 0

        ];

    }



    public function get(string $key): mixed {

        if (!isset($this->storage[$key])) {

            return null;

        }



        if (time() > $this->storage[$key]['expires']) {

            unset($this->storage[$key]);

            return null;

        }



        $this->storage[$key]['hits']++;

        $this->analytics[$key] = ($this->analytics[$key] ?? 0) + 1;



        return $this->storage[$key]['value'];

    }



    public function getAnalytics(): array {

        return $this->analytics;

    }

}



// Registering different instances for different contexts

Orbis::register(new SmartCache(), 'user.cache');

Orbis::register(new SmartCache(), 'product.cache');



// Anywhere in your application

function cacheUser(User $user): void {

    $cache = Orbis::instance('user.cache');

    $cache->set("user.{$user->id}", $user);

}



function getUser(int $id): ?User {

    $cache = Orbis::instance('user.cache');

    return $cache->get("user.{$id}");

}

Why Is This Revolutionary? 🌟

1. 
   Automatic Isolation: Each context has its own cache instance.


2. 
   Zero Configuration: No need to configure anything in bootstrap or providers.


3. 
   Integrated Analytics: Automatic tracking of cache usage.


4. 
   Optimized Performance: Instances are automatically reused.

Using Orbis in Your Project

Installation via Composer:

composer require lithemod/orbis

Basic Example:

// Register an instance

Orbis::register(MyClass::class);



// Use it anywhere

$instance = Orbis::instance(MyClass::class);

Conclusion 🎯

Orbis is not just another dependency management library – it’s a new way of thinking about abstraction and code reuse in PHP. With it, you can:

• Simplify complex code.


• Improve project organization.


• Reduce coupling between components.


• Make testing and maintenance easier.

Try Orbis today and discover how it can transform your PHP code into something truly magical! ✨

To understand more about how Orbis works, read the post How to Use Orbis to Simplify Your PHP Code and discover its potential in practice!