nur-sery/wip/app/app2.php

<?php
namespace nur\sery\wip\app;

use nur\b\ExitError;
use nur\cli\Application;
use nur\cli\Application2;
use nur\sery\A;
use nur\sery\app\LockFile;
use nur\sery\app\RunFile;
use nur\sery\cl;
use nur\sery\os\path;
use nur\sery\os\sh;
use nur\sery\output\msg;
use nur\sery\php\func;
use nur\sery\str;
use nur\sery\ValueException;

class app2 {
  static ?func $bgapplication_enabled = null;

  /**
   * spécifier la fonction permettant de vérifier si l'exécution de tâches
   * de fond est autorisée. Si cette méthode n'est pas utilisée, par défaut,
   * les tâches planifiées sont autorisées
   *
   * si $func===true, spécifier une fonction qui retourne toujours vrai
   * si $func===false, spécifiée une fonction qui retourne toujours faux
   * sinon, $func doit être une fonction valide
   */
  static function set_bgapplication_enabled($func): void {
    if (is_bool($func)) {
      $enabled = $func;
      $func = function () use ($enabled) {
        return $enabled;
      };
    }
    self::$bgapplication_enabled = func::with($func);
  }

  /**
   * Si les exécutions en tâche de fond sont autorisée, retourner. Sinon
   * afficher une erreur et quitter l'application
   */
  static function check_bgapplication_enabled(bool $forceEnabled=false): void {
    if (self::$bgapplication_enabled === null) return;
    $enabled = boolval(self::$bgapplication_enabled->invoke());
    if (!$forceEnabled && !$enabled) {
      msg::debug("Planifications désactivées. La tâche n'a pas été lancée");
      throw new ExitError();
    }
  }

  #############################################################################

  private static function isa_Application($app): bool {
    if (!is_string($app)) return false;
    return $app === Application::class || is_subclass_of($app, Application::class) ||
      $app === Application2::class || is_subclass_of($app, Application2::class);
  }

  private static function get_params($app): array {
    if ($app instanceof self) {
      $params = $app->getParams();
    } elseif ($app instanceof Application || $app instanceof Application2) {
      $class = get_class($app);
      $params = [
        "class" => $class,
        "projdir" => $app::PROJDIR,
        "vendor" => $app::VENDOR,
        "appcode" => $app::APPCODE,
        "datadir" => $app::DATADIR,
        "etcdir" => $app::ETCDIR,
        "vardir" => $app::VARDIR,
        "logdir" => $app::LOGDIR,
        "appgroup" => $app::APPGROUP,
        "name" => $app::NAME,
        "title" => $app::TITLE,
      ];
    } elseif (self::isa_Application($app)) {
      $class = $app;
      $params = [
        "class" => $class,
        "projdir" => constant("$app::PROJDIR"),
        "vendor" => constant("$app::VENDOR"),
        "appcode" => constant("$app::APPCODE"),
        "datadir" => constant("$app::DATADIR"),
        "etcdir" => constant("$app::ETCDIR"),
        "vardir" => constant("$app::VARDIR"),
        "logdir" => constant("$app::LOGDIR"),
        "appgroup" => constant("$app::APPGROUP"),
        "name" => constant("$app::NAME"),
        "title" => constant("$app::TITLE"),
      ];
    } elseif (is_array($app)) {
      $params = $app;
    } else {
      throw ValueException::invalid_type($app, Application::class);
    }
    return $params;
  }

  protected static ?self $app = null;

  /**
   * @param Application|string|array $app
   * @param Application|string|array|null $proj
   */
  static function with($app, $proj=null): self {
    $params = self::get_params($app);
    $proj ??= self::$app;
    $proj_params = $proj !== null? self::get_params($proj): null;
    if ($proj_params !== null) {
      A::merge($params, cl::select($proj_params, [
        "projdir",
        "vendor",
        "appcode",
        "cwd",
        "datadir",
        "etcdir",
        "vardir",
        "logdir",
        "profile",
      ]));
    }
    return new static($params, $proj_params !== null);
  }

  static function init($app, $proj=null): void {
    self::$app = static::with($app, $proj);
  }

  static function get(): self {
    return self::$app ??= new self(null);
  }

  /**
   * @var array répertoires vendor exprimés relativement à PROJDIR
   */
  const DEFAULT_VENDOR = [
    "bindir" => "vendor/bin",
    "autoload" => "vendor/autoload.php",
  ];

  function __construct(?array $params, bool $useProjParams=false) {
    if ($useProjParams) {
      [
        "projdir" => $projdir,
        "vendor" => $vendor,
        "appcode" => $appcode,
        "datadir" => $datadir,
        "etcdir" => $etcdir,
        "vardir" => $vardir,
        "logdir" => $logdir,
      ] = $params;
      $cwd = $params["cwd"] ?? null;
      $datadirIsDefined = true;
      $profile = $params["profile"] ?? null;
    } else {
      # projdir
      $projdir = $params["projdir"] ?? null;
      if ($projdir === null) {
        global $_composer_autoload_path, $_composer_bin_dir;
        $autoload = $_composer_autoload_path ?? null;
        $bindir = $_composer_bin_dir ?? null;
        if ($autoload !== null) {
          $vendor = preg_replace('/\/[^\/]+\.php$/', "", $autoload);
          $bindir ??= "$vendor/bin";
          $projdir = preg_replace('/\/[^\/]+$/', "", $vendor);
          $params["vendor"] = [
            "autoload" => $autoload,
            "bindir" => $bindir,
          ];
        }
      }
      if ($projdir === null) $projdir = ".";
      $projdir = path::abspath($projdir);
      # vendor
      $vendor = $params["vendor"] ?? self::DEFAULT_VENDOR;
      $vendor["bindir"] = path::reljoin($projdir, $vendor["bindir"]);
      $vendor["autoload"] = path::reljoin($projdir, $vendor["autoload"]);
      # appcode
      $appcode = $params["appcode"] ?? null;
      if ($appcode === null) {
        $appcode = str::without_suffix("-app", path::basename($projdir));
      }
      $APPCODE = str_replace("-", "_", strtoupper($appcode));
      # cwd
      $cwd = $params["cwd"] ?? null;
      # datadir
      $datadir = getenv("${APPCODE}_DATADIR");
      $datadirIsDefined = $datadir !== false;
      if ($datadir === false) $datadir = $params["datadir"] ?? null;
      if ($datadir === null) $datadir = "devel";
      $datadir = path::reljoin($projdir, $datadir);
      # etcdir
      $etcdir = getenv("${APPCODE}_ETCDIR");
      if ($etcdir === false) $etcdir = $params["etcdir"] ?? null;
      if ($etcdir === null) $etcdir = "etc";
      $etcdir = path::reljoin($datadir, $etcdir);
      # vardir
      $vardir = getenv("${APPCODE}_VARDIR");
      if ($vardir === false) $vardir = $params["vardir"] ?? null;
      if ($vardir === null) $vardir = "var";
      $vardir = path::reljoin($datadir, $vardir);
      # logdir
      $logdir = getenv("${APPCODE}_LOGDIR");
      if ($logdir === false) $logdir = $params["logdir"] ?? null;
      if ($logdir === null) $logdir = "log";
      $logdir = path::reljoin($datadir, $logdir);
      # profile
      $profile = getenv("${APPCODE}_PROFILE");
      if ($profile === false) $profile = getenv("APP_PROFILE");
      if ($profile === false) $profile = $params["profile"] ?? null;
    }
    # cwd
    $cwd ??= getcwd();
    # profile
    $profile ??= $datadirIsDefined? "prod": "devel";

    $this->projdir = $projdir;
    $this->vendor = $vendor;
    $this->appcode = $appcode;
    $this->cwd = $cwd;
    $this->datadir = $datadir;
    $this->etcdir = $etcdir;
    $this->vardir = $vardir;
    $this->logdir = $logdir;
    $this->profile = $profile;

    # name, title
    $appgroup = $params["appgroup"] ?? null;
    $name = $params["name"] ?? $params["class"] ?? null;
    if ($name === null) {
      $name = $appcode;
    } else {
      # si $name est une classe, enlever le package et normaliser i.e
      # my\package\MyApplication --> my-application
      $name = preg_replace('/.*\\\\/', "", $name);
      $name = str::camel2us($name, false, "-");
    }
    $this->appgroup = $appgroup;
    $this->name = $name;
    $this->title = $params["title"] ?? null;
  }

  #############################################################################
  # Paramètres partagés par tous les scripts d'un projet (et les scripts lancés
  # à partir d'une application de ce projet)

  protected string $projdir;

  function getProjdir(): string {
    return $this->projdir;
  }

  protected array $vendor;

  function getVendorBindir(): string {
    return $this->vendor["bindir"];
  }

  function getVendorAutoload(): string {
    return $this->vendor["autoload"];
  }

  protected string $appcode;

  function getAppcode(): string {
    return $this->appcode;
  }

  protected string $cwd;

  function getCwd(): string {
    return $this->cwd;
  }

  protected string $datadir;

  function getDatadir(): string {
    return $this->datadir;
  }

  protected string $etcdir;

  function getEtcdir(): string {
    return $this->etcdir;
  }

  protected string $vardir;

  function getVardir(): string {
    return $this->vardir;
  }

  protected string $logdir;

  function getLogdir(): string {
    return $this->logdir;
  }

  protected string $profile;

  function getProfile(): string {
    return $this->profile;
  }

  /**
   * @param ?string|false $profile
   *
   * false === pas de profil
   * null === profil par défaut
   */
  function withProfile(string $file, $profile): string {
    if ($profile !== false) {
      if ($profile === null) $profile = $this->getProfile();
      [$dir, $filename] = path::split($file);
      $basename = path::basename($filename);
      $ext = path::ext($file);
      $file = path::join($dir, "$basename.$profile$ext");
    }
    return $file;
  }

  function findFile(array $dirs, array $names, $profile=null): string {
    # d'abord chercher avec le profil
    if ($profile !== false) {
      foreach ($dirs as $dir) {
        foreach ($names as $name) {
          $file = path::join($dir, $name);
          $file = $this->withProfile($file, $profile);
          if (file_exists($file)) return $file;
        }
      }
    }
    # puis sans profil
    foreach ($dirs as $dir) {
      foreach ($names as $name) {
        $file = path::join($dir, $name);
        if (file_exists($file)) return $file;
      }
    }
    # la valeur par défaut est avec profil
    return $this->withProfile(path::join($dirs[0], $names[0]), $profile);
  }

  function fencedJoin(string $basedir, string $path): string {
    $path = path::reljoin($basedir, $path);
    if (!path::is_within($path, $basedir)) {
      throw ValueException::invalid_value($path, "path");
    }
    return $path;
  }

  #############################################################################
  # Paramètres spécifiques à cette application

  protected string $appgroup;

  function getAppgroup(): ?string {
    return $this->appgroup;
  }

  protected string $name;

  function getName(): ?string {
    return $this->name;
  }

  protected ?string $title;

  function getTitle(): ?string {
    return $this->title;
  }

  #############################################################################
  # Méthodes outils

  /** recréer le tableau des paramètres */
  function getParams(): array {
    return [
      "projdir" => $this->projdir,
      "vendor" => $this->vendor,
      "appcode" => $this->appcode,
      "cwd" => $this->cwd,
      "datadir" => $this->datadir,
      "etcdir" => $this->etcdir,
      "vardir" => $this->vardir,
      "logdir" => $this->logdir,
      "profile" => $this->profile,
      "appgroup" => $this->appgroup,
      "name" => $this->name,
      "title" => $this->title,
    ];
  }

  function getEtcfile(?string $name=null, $profile=null): string {
    if ($name === null) $name = "{$this->name}.conf";
    return $this->findFile([$this->etcdir], [$name], $profile);
  }

  function getVarfile(?string $name=null, $profile=null): string {
    if ($name === null) $name = "{$this->name}.tmp";
    $file = $this->withProfile($this->fencedJoin($this->vardir, $name), $profile);
    sh::mkdirof($file);
    return $file;
  }

  function getLogfile(?string $name=null, $profile=null): string {
    if ($name === null) $name = "{$this->name}.log";
    $file = $this->withProfile($this->fencedJoin($this->logdir, $name), $profile);
    sh::mkdirof($file);
    return $file;
  }

  /**
   * obtenir le chemin absolu vers un fichier de travail
   * - si le chemin est absolu, il est inchangé
   * - si le chemin est qualifié (commence par ./ ou ../) ou sans chemin, il est
   * exprimé par rapport à $vardir
   * - sinon le chemin est exprimé par rapport au répertoire de travail de base
   * $datadir
   *
   * is $ensure_dir, créer le répertoire du fichier s'il n'existe pas déjà
   */
  function getWorkfile(?string $file, $profile=null, bool $ensureDir=true): ?string {
    if ($file === null) return null;
    if (path::is_qualified($file) || !path::have_dir($file)) {
      $file = path::reljoin($this->vardir, $file);
    } else {
      $file = path::reljoin($this->datadir, $file);
    }
    $file = $this->withProfile($file, $profile);
    if ($ensureDir) sh::mkdirof($file);
    return $file;
  }

  /**
   * obtenir le chemin absolu vers un fichier spécifié par l'utilisateur.
   * - si le chemin commence par /, il est laissé en l'état
   * - si le chemin commence par ./ ou ../, il est exprimé par rapport à $cwd
   * - sinon le chemin est exprimé par rapport au répertoire de travail $vardir
   */
  function getUserfile(?string $file): ?string {
    if ($file === null) return null;
    if (path::is_qualified($file)) {
      return path::reljoin($this->cwd, $file);
    } else {
      return path::reljoin($this->vardir, $file);
    }
  }

  protected ?RunFile $runfile = null;

  function getRunfile(): RunFile {
    $name = $this->name;
    $runfile = $this->getWorkfile($name);
    $logfile = $this->getLogfile($name);
    return $this->runfile ??= new RunFile($name, $runfile, $logfile);
  }

  protected ?array $lockFiles = null;

  function getLockfile(?string $name=null): LockFile {
    $this->lockFiles[$name] ??= $this->getRunfile()->getLockFile($name, $this->title);
    return $this->lockFiles[$name];
  }
}