cms11/app/Classes/MetadataManager.php

<?php

namespace App\Classes;

use Illuminate\Filesystem\FilesystemAdapter;

/**
 * Class MetadataManager
 *
 * This class is designed to handle metadata for articles or any other items that
 * might have associated metadata stored in a JSON format. It uses Laravel's
 * Collections for flexible data manipulation and the disk for storage.
 */
class MetadataManager
{
    protected $originalContent;

    protected $content;

    protected FilesystemAdapter $disk;

    protected bool $isLoaded = false;

    /**
     * Constructor for the MetadataManager class.
     *
     * @param  string  $filename  The filename where metadata is stored.
     * @param  disk  $disk  The disk abstraction provided by Laravel.
     */
    public function __construct(protected string $filename, protected Bundle $bundle)
    {
        $this->disk = $bundle->getDisk();

        $this->load();
    }

    public function getFilename(): string
    {
        return $this->filename;
    }

    /**
     * Loads metadata from disk using the disk, with caching to improve performance.
     */
    public function load(bool $reload = false)
    {
        if (!$this->isLoaded || $reload) {
            $data = $this->readFromDisk();

            $this->originalContent = $data;
            $this->content         = $data;
            $this->isLoaded        = true;
        }
    }

    /**
     * Checks if the content has been modified since it was last loaded or saved.
     *
     * @return bool True if the content is dirty (modified), false otherwise.
     */
    public function isDirty(): bool
    {
        return collect($this->originalContent)->toJson() != collect($this->content)->toJson();
    }

    /**
     * Saves the metadata to disk if it has been modified (is dirty).
     *
     * @return bool True if the data was saved successfully, false otherwise.
     */
    public function save(): bool
    {
        if (!$this->isDirty()) {
            return false;
        }

        if (empty($this->content)) {
            $this->disk->delete($this->filename);
        } else {
            $this->writeToDisk($this->content);
        }

        $this->originalContent = $this->content;

        return true;
    }

    /**
     * Sets a metadata value for a specified key.
     *
     * @param  mixed  $key  The key under which to store the value.
     * @param  mixed  $value  The value to store.
     */
    public function set($key, $value, bool $respectDots = true)
    {
        if ($respectDots) {
            data_set($this->content, $key, $value, true);
        } else {
            $this->content[$key] = $value;
        }
    }

    /**
     * Set many values at once
     */
    public function setMany(array $array, bool $replace = false)
    {
        if (!$replace) {
            foreach ($array as $key => $value) {
                $this->set($key, $value);
            }
        } else {
            $this->content = $array;
        }
    }

    /**
     * Forget any metadata in this file.
     */
    public function clear()
    {
        $this->content = [];
    }

    public function merge(array $array)
    {
        $content    = collect($this->content)->dot();
        $newValue   = collect($array)->dot();
        $newContent = collect($content)->mergeRecursive($newValue)->undot()->toArray();

        $this->content = $newContent;
    }

    /**
     * Retrieves a metadata value by key.
     *
     * @param  mixed  $key  The key of the value to retrieve.
     * @param  mixed  $default  The default value to return if the key does not exist.
     * @return mixed The value of the specified key, or the default value.
     */
    public function get($key, $default = null, bool $respectDots = true)
    {
        if ($respectDots) {
            return data_get($this->content, $key, $default);
        } else {
            return $this->content[$key] ?? $default;
        }
    }

    /**
     * Retrieves all metadata as an associative array.
     *
     * @return array The content of the metadata.
     */
    public function all()
    {
        return $this->content;
    }

    /**
     * Removes a metadata entry by key.
     *
     * @param  mixed  $key  The key of the entry to remove.
     */
    public function remove($key)
    {
        if (is_array($key)) {
            foreach ($key as $k) {
                data_forget($this->content, $k);
            }
        } else {
            data_forget($this->content, $key);
        }
    }

    /**
     * Reads metadata from disk. Caches the content to reduce file system reads.
     *
     * @return array The data read from the file.
     */
    protected function readFromDisk()
    {
        $data = $this->disk->get($this->filename) ?? '[]';

        return json_decode($data, true);
    }

    /**
     * Writes the provided data to disk as JSON.
     *
     * @param  array  $data  The data to write to disk.
     */
    protected function writeToDisk(array $data)
    {
        $json = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

        $this->disk->put($this->filename, $json);
    }
}