JsonContainer::applyDefaults() - Code Metrics - Inspection of "0b4ab12c868e3131074210307f2e5cc41b327708" - derafu/derafu-lib-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (0b4ab1)

by Esteban De La Fuente

created 2024-12-29 12:58 UTC

JsonContainer::applyDefaults() B

↳ Parent: JsonContainer

Complexity

Conditions	8
Paths	5

Size

Total Lines	20
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	8

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	8
eloc	10
c	1
b	0
f	0
nc	5
nop	2
dl	0
loc	20
ccs	10
cts	10
cp	1
crap	8
rs	8.4444

<?php

declare(strict_types=1);

/**
 * Derafu: Biblioteca PHP (Núcleo).
 * Copyright (C) Derafu <https://www.derafu.org>
 *
 * Este programa es software libre: usted puede redistribuirlo y/o modificarlo
 * bajo los términos de la Licencia Pública General Affero de GNU publicada por
 * la Fundación para el Software Libre, ya sea la versión 3 de la Licencia, o
 * (a su elección) cualquier versión posterior de la misma.
 *
 * Este programa se distribuye con la esperanza de que sea útil, pero SIN
 * GARANTÍA ALGUNA; ni siquiera la garantía implícita MERCANTIL o de APTITUD
 * PARA UN PROPÓSITO DETERMINADO. Consulte los detalles de la Licencia Pública
 * General Affero de GNU para obtener una información más detallada.
 *
 * Debería haber recibido una copia de la Licencia Pública General Affero de GNU
 * junto a este programa.
 *
 * En caso contrario, consulte <http://www.gnu.org/licenses/agpl.html>.
 */

namespace Derafu\Lib\Core\Support\Store;

use Derafu\Lib\Core\Support\Store\Abstract\AbstractStore;
use Derafu\Lib\Core\Support\Store\Contract\DataContainerInterface;
use InvalidArgumentException;
use Opis\JsonSchema\Errors\ErrorFormatter;
use Opis\JsonSchema\Helper;
use Opis\JsonSchema\Validator;
use stdClass;

/**
 * Clase para contenedor de datos estructurados con JSON Schema.
 */
class JsonContainer extends AbstractStore implements DataContainerInterface
{
    /**
     * Configuración del schema de datos.
     *
     * @var stdClass
     */
    protected ?stdClass $schema = null;

    /**
     * Instancia que representa el formateador de los errores del validador.
     *
     * @var ErrorFormatter
     */
    private ErrorFormatter $formatter;

    /**
     * Constructor del contenedor.
     *
     * @param array $data Datos iniciales.
     * @param array $schema Schema inicial.
     */
    public function __construct(array $data = [], array $schema = [])
    {
        $this->formatter = new ErrorFormatter();
        $this->setSchema($schema);
        $this->data = $this->resolve($data, $this->schema);
        $this->data = $this->resolve($data, /** @scrutinizer ignore-type */ $this->schema);
    }

    /**
     * {@inheritdoc}
     */
    public function setSchema(array $schema): static
    {
        $schema = array_merge([
            '$schema' => 'https://json-schema.org/draft/2020-12/schema',
            'type' => 'object',
        ], $schema);

        $this->schema = Helper::toJSON($schema);
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getSchema(): array
    {
        return json_decode(json_encode($this->schema), true);
    }

    /**
     * {@inheritdoc}
     */
    public function validate(): void
    {
        $this->resolve($this->data, $this->schema);
        $this->resolve($this->data, /** @scrutinizer ignore-type */ $this->schema);
    }

    /**
     * Valida y resuelve datos usando un schema JSON.
     *
     * @param array $data Datos a validar.
     * @param stdClass $schema Schema JSON a usar.
     * @return array Datos validados y con valores por defecto aplicados.
     */
    private function resolve(array $data, stdClass $schema): array
    {
        if (!isset($schema->properties)) {
            return $data;
        }

        $data = $this->applyDefaults($data, $schema);
        $json = json_decode(json_encode($data));

        $validator = new Validator();
        $result = $validator->validate($json, $schema);

        if ($result->hasError()) {
            $errors = [];
            foreach ($this->formatter->format($result->error()) as $section => $messages) {
                foreach ($messages as $message) {
                    $errors[] = $message . ' in ' . $section . '.';
                }
            }
            throw new InvalidArgumentException(sprintf(
                'Error al validar el esquema JSON de los datos. %s',
                implode(' ', $errors)
            ));
        }

        return $data;
    }

    /**
     * Aplica valores por defecto recursivamente.
     *
     * @param array $data Datos a procesar.
     * @param stdClass $schema Schema con valores por defecto.
     * @return array Datos con valores por defecto aplicados.
     */
    private function applyDefaults(array $data, stdClass $schema): array
    {
        foreach ($schema->properties as $key => $property) {
            // Aplicar valor por defecto si la propiedad no existe.
            if (!isset($data[$key]) && isset($property->default)) {
                $data[$key] = $property->default;
            }

            // Recursión para objetos anidados.
            if (
                isset($data[$key])
                && isset($property->type)
                && $property->type === 'object'
                && isset($property->properties)
            ) {
                $data[$key] = $this->applyDefaults($data[$key], $property);
            }
        }

        return $data;
    }
}


derafu / derafu-lib-core

Branch — master (0b4ab1)

JsonContainer::applyDefaults() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like