Packaging des modules Dolibarr

Automatiser le packaging des modules Dolibarr sur macOS

Lorsqu’on développe des modules Dolibarr, la création des fichiers ZIP est souvent faite manuellement. Ce fonctionnement paraît simple, mais il introduit rapidement des erreurs : mauvaise version, nom de fichier incohérent, fichiers inutiles inclus dans l’archive.

Le script présenté ici automatise ce processus pour produire des archives propres, cohérentes et directement exploitables.

Le principe est simple. Le script est placé dans un dossier contenant un module Dolibarr. Il détecte automatiquement ce module, lit sa version directement dans le code source, puis génère une archive ZIP nommée correctement.

Par exemple, pour un module syncdolibarrodoo contenant :

$this->version='7.3.0';

le script produira :

module_syncdolibarrodoo-7.3.0.zip

La version utilisée est donc celle du code, ce qui évite toute désynchronisation entre le livrable et l’implémentation réelle.

Le script s’appuie sur la structure standard des modules Dolibarr. Il va chercher le fichier présent dans core/modules/mod*.class.php et extrait la version définie dans la propriété $this->version.

Lors de la création de l’archive, il exclut automatiquement les éléments inutiles ou problématiques comme les fichiers cachés, les dossiers .git, les fichiers système macOS ou encore les dépendances non nécessaires. Le ZIP obtenu est directement prêt à être livré ou installé.

L’intérêt principal n’est pas le gain de temps mais la fiabilité. Le processus devient déterministe : même entrée, même sortie. Cela réduit fortement les erreurs humaines et permet de standardiser les livrables, ce qui devient important dès que plusieurs modules ou plusieurs intervenants sont impliqués.

Ce type d’automatisation s’intègre facilement dans un processus plus large. Il peut servir de base à un système de versioning, à un pipeline CI/CD ou à une gestion plus rigoureuse des releases.

Le script repose volontairement sur une hypothèse simple : un seul module est présent dans le dossier. Cela évite toute ambiguïté et force un usage propre.

En pratique, c’est un outil minimaliste mais structurant. Tant que le packaging reste manuel, les erreurs sont inévitables. Dès qu’il est automatisé, il disparaît comme sujet.

#!/bin/bash

set -e

# ------------------------------------------------------------------
# build-dolibarr-module-zip.sh
#
# But :
# - être lancé depuis le dossier parent qui contient UN module Dolibarr
# - détecter le dossier module automatiquement
# - lire la version dans :
#     <module>/core/modules/mod*.class.php
# - construire :
#     module_<nommodule>-<version>.zip
# - exclure les fichiers/dossiers cachés et parasites (.git, .DS_Store, etc.)
# ------------------------------------------------------------------

CURRENT_DIR="$(pwd)"

echo "Répertoire courant : $CURRENT_DIR"

# Trouver les dossiers non cachés à la racine
MODULE_DIRS=""
COUNT=0

for d in */ ; do
    [ -d "$d" ] || continue

    # retire le slash final
    dir_name="${d%/}"

    # ignore les dossiers cachés
    case "$dir_name" in
        .*) continue ;;
    esac

    COUNT=$((COUNT + 1))
    MODULE_DIRS="$MODULE_DIRS $dir_name"
done

if [ "$COUNT" -eq 0 ]; then
    echo "Erreur : aucun dossier module trouvé dans $CURRENT_DIR"
    exit 1
fi

if [ "$COUNT" -gt 1 ]; then
    echo "Erreur : plusieurs dossiers trouvés :"
    for name in $MODULE_DIRS; do
        echo " - $name"
    done
    echo "Laisse un seul dossier module dans ce répertoire avant d'exécuter le script."
    exit 1
fi

MODULE_DIR="$(echo "$MODULE_DIRS" | awk '{print $1}')"

if [ ! -d "$MODULE_DIR/core/modules" ]; then
    echo "Erreur : dossier introuvable : $MODULE_DIR/core/modules"
    exit 1
fi

# Chercher le fichier mod*.class.php
MOD_FILE=""
for f in "$MODULE_DIR"/core/modules/mod*.class.php; do
    if [ -f "$f" ]; then
        MOD_FILE="$f"
        break
    fi
done

if [ -z "$MOD_FILE" ]; then
    echo "Erreur : aucun fichier mod*.class.php trouvé dans $MODULE_DIR/core/modules"
    exit 1
fi

echo "Fichier module détecté : $MOD_FILE"

# Extraire la version depuis une ligne comme :
# $this->version='7.3.0';
# ou
# $this->version = "7.3.0";
VERSION="$(sed -n "s/.*\$this->version[[:space:]]*=[[:space:]]*['\"]\([^'\"]*\)['\"].*/\1/p" "$MOD_FILE" | head -n 1)"

if [ -z "$VERSION" ]; then
    echo "Erreur : impossible d'extraire la version depuis $MOD_FILE"
    exit 1
fi

ZIP_NAME="module_${MODULE_DIR}-${VERSION}.zip"

echo "Module détecté : $MODULE_DIR"
echo "Version détectée : $VERSION"
echo "Archive cible   : $ZIP_NAME"

# Supprime l'archive existante si elle existe déjà
if [ -f "$ZIP_NAME" ]; then
    rm -f "$ZIP_NAME"
fi

# Création du zip
# Exclusions :
# - fichiers/dossiers cachés
# - .git
# - fichiers macOS parasites
# - .svn
# - node_modules
zip -r "$ZIP_NAME" "$MODULE_DIR" \
  -x "*/.*" \
  -x "__MACOSX/*" \
  -x "*/__MACOSX/*" \
  -x "*.DS_Store" \
  -x "*/.git/*" \
  -x "*/.gitignore" \
  -x "*/.svn/*" \
  -x "*/node_modules/*"

echo "OK : archive créée -> $ZIP_NAME"

Let’s go 🙂