nur-sery/src/schema/_scalar/ScalarSchema.php

<?php
namespace nur\sery\schema\_scalar;

use nulib\cl;
use nur\sery\ref\schema\ref_schema;
use nur\sery\ref\schema\ref_types;
use nur\sery\schema\Schema;
use nur\sery\schema\SchemaException;
use nur\sery\schema\types\tarray;
use nur\sery\schema\types\tbool;
use nur\sery\schema\types\tcallable;
use nur\sery\schema\types\tcontent;
use nur\sery\schema\types\tpkey;
use nur\sery\schema\types\tstring;
use nur\sery\schema\Value;

/**
 * Class ScalarSchema
 * 
 * @property-read array $type
 * @property-read mixed $default
 * @property-read string|null $title
 * @property-read bool $required
 * @property-read bool $nullable
 * @property-read string|array|null $desc
 * @property-read callable|null $analyzerFunc
 * @property-read callable|null $extractorFunc
 * @property-read callable|null $parserFunc
 * @property-read callable|null $normalizerFunc
 * @property-read array|null $messages
 * @property-read callable|null $formatterFunc
 * @property-read mixed $format
 * @property-read array $nature
 * @property-read string|int|null $name
 * @property-read string|array|null $pkey
 * @property-read string|null $header
 * @property-read bool|null $composite
 */
class ScalarSchema extends Schema {
  /** @var array meta-schema d'un schéma de nature scalaire */
  const METASCHEMA = ref_schema::SCALAR_METASCHEMA;

  /**
   * indiquer si $definition est une définition de schéma scalaire que
   * {@link normalize()} pourrait normaliser
   */
  static function isa_definition($definition): bool {
    # chaine ou null
    if ($definition === null) return true;
    if (is_string($definition)) return true;
    if (!is_array($definition)) return false;
    # nature explicitement spécifiée
    if (array_key_exists("", $definition)) {
      $nature = $definition[""];
      if ($nature === "scalar") return true;
      if (is_array($nature)
        && array_key_exists(0, $nature)
        && $nature[0] === "scalar") {
        return true;
      }
      return false;
    }
    # un unique élément chaine à l'index 0
    $count = count($definition);
    $haveIndex0 = array_key_exists(0, $definition);
    if ($count == 1 && $haveIndex0
      && ($definition[0] === null || is_string($definition[0]))) {
      return true;
    }
    # un élément à l'index 0, et d'autres éléments
    return $haveIndex0 && $count > 1;
  }

  static function normalize($definition, $definitionKey=null): array {
    if (!is_array($definition)) $definition = [$definition];
    # s'assurer que toutes les clés existent avec leur valeur par défaut
    $index = 0;
    foreach (array_keys(self::METASCHEMA) as $key) {
      if (!array_key_exists($key, $definition)) {
        if (array_key_exists($index, $definition)) {
          $definition[$key] = $definition[$index];
          unset($definition[$index]);
          $index++;
        } else {
          $definition[$key] = self::METASCHEMA[$key][1];
        }
      }
    }
    # réordonner les clés numériques
    if (cl::have_num_keys($definition)) {
      $keys = array_keys($definition);
      $index = 0;
      foreach ($keys as $key) {
        if (!is_int($key)) continue;
        $definition[$index] = $definition[$key];
        unset($definition[$key]);
        $index++;
      }
    }
    # type
    $types = [];
    $deftype = $definition["type"];
    $nullable = $definition["nullable"];
    if ($deftype === null) {
      $types[] = null;
      $nullable = true;
    } else {
      if (!is_array($deftype)) {
        if (!is_string($deftype)) throw SchemaException::invalid_type($deftype);
        $deftype = explode("|", $deftype);
      }
      foreach ($deftype as $type) {
        if ($type === null || $type === "null") {
          $nullable = true;
          continue;
        }
        if (!is_string($type)) throw SchemaException::invalid_type($type);
        if (substr($type, 0, 1) == "?") {
          $type = substr($type, 1);
          $nullable = true;
        }
        if ($type === "") throw SchemaException::invalid_type($type);
        $type = cl::get(ref_types::ALIASES, $type, $type);
        $types = array_merge($types, explode("|", $type));
      }
      if (!$types) throw SchemaException::invalid_schema("scalar: type is required");
      $types = array_keys(array_fill_keys($types, true));
    }
    $definition["type"] = $types;
    $definition["nullable"] = $nullable;
    # nature
    $nature = $definition[""];
    tarray::ensure_array($nature);
    if (!array_key_exists(0, $nature) || $nature[0] !== "scalar") {
      throw SchemaException::invalid_schema("expected scalar nature");
    }
    $definition[""] = $nature;
    # name, pkey, header
    $name = $definition["name"];
    $pkey = $definition["pkey"];
    $header = $definition["header"];
    if ($name === null) $name = $definitionKey;
    tstring::ensure_nstring($name);
    tpkey::ensure_npkey($pkey);
    tstring::ensure_nstring($header);
    if ($pkey === null) $pkey = $name;
    if ($header === null) $header = $name;
    $definition["name"] = $name;
    $definition["pkey"] = $pkey;
    $definition["header"] = $header;
    # autres éléments
    tstring::ensure_nstring($definition["title"]);
    tbool::ensure_bool($definition["required"]);
    tbool::ensure_bool($definition["nullable"]);
    tcontent::ensure_ncontent($definition["desc"]);
    tcallable::ensure_ncallable($definition["analyzer_func"]);
    tcallable::ensure_ncallable($definition["extractor_func"]);
    tcallable::ensure_ncallable($definition["parser_func"]);
    tcallable::ensure_ncallable($definition["normalizer_func"]);
    tarray::ensure_narray($definition["messages"]);
    tcallable::ensure_ncallable($definition["formatter_func"]);
    tbool::ensure_nbool($definition["composite"]);
    return $definition;
  }

  function __construct($definition=null, $definitionKey=null, bool $normalize=true) {
    if ($definition === null) $definition = static::SCHEMA;
    if ($normalize) $definition = self::normalize($definition, $definitionKey);
    $this->definition = $definition;
  }

  function isScalar(?ScalarSchema &$scalar=null): bool {
    $scalar = $this;
    return true;
  }

  function newValue(?Value &$destv=null, &$dest=null, $destKey=null): ScalarValue {
    if ($destv instanceof ScalarValue) return $destv->reset($dest, $destKey);
    else return ($destv = new ScalarValue($this, $dest, $destKey));
  }

  #############################################################################
  # key & properties

  const _PROPERTY_PKEYS = [
    "analyzerFunc" => "analyzer_func",
    "extractorFunc" => "extractor_func",
    "parserFunc" => "parser_func",
    "normalizerFunc" => "normalizer_func",
    "formatterFunc" => "formatter_func",
    "nature" => ["", 0],
  ];
}