# Les Carnets d’Akkadien

**Les Carnets d’Akkadien** est un site personnel consacré à l’apprentissage de l’akkadien et de l’écriture cunéiforme. Il rassemble des fiches de vocabulaire et de signes, des notes de grammaire, des textes étudiés et des articles de parcours.

Site public : <https://lescarnetsdakkadien.netig.net>

Le site est construit avec [Zola](https://www.getzola.org/) à partir de fichiers Markdown. Il ne nécessite ni base de données ni interface d’administration : les contenus restent lisibles et modifiables comme de simples fichiers texte.

## Sections du site

- **Signes** : signes cunéiformes classés par numéro MZL et par lecture ;
- **Vocabulaire** : fiches adaptées à la nature grammaticale des mots ;
- **Grammaire** : notes organisées par thème ;
- **Textes** : translittérations, traductions et commentaires classés par genre ;
- **Articles** : billets consacrés à l’apprentissage et au projet.

La page d’accueil présente le dernier article et les trois fiches les plus récemment publiées ou mises à jour. Des flux Atom et RSS sont également générés.

## Prérequis

Pour travailler directement sur le projet :

- Python 3.11 ou ultérieur ;
- Zola 0.22.1 ;
- Git, si le dépôt est versionné avec Git.

Pour le déploiement conteneurisé :

- Docker Engine ;
- Docker Compose.

Toutes les commandes ci-dessous sont exécutées depuis la racine du dépôt.

## Développement local

Valider les contenus :

```sh
./scripts/check-content.py
```

Vérifier la construction Zola, brouillons compris :

```sh
zola --root src check --drafts --skip-external-links
```

`--skip-external-links` évite de dépendre du réseau. Retirer cette option pour vérifier également les liens externes.

Lancer le serveur de développement :

```sh
zola --root src serve
```

Afficher également les brouillons :

```sh
zola --root src serve --drafts
```

Construire le site statique :

```sh
zola --root src build
```

Le résultat est écrit dans `src/public/`, répertoire ignoré par Git.

## Rédaction des contenus

Les contenus sont rédigés en Markdown dans `src/content/`. Des scripts permettent de créer les squelettes, d’horodater les modifications substantielles et de vérifier les fiches avant publication.

Les conventions éditoriales, les commandes et les modèles de chaque type de fiche sont décrits dans le [guide de rédaction](GUIDE_REDACTION.md).

## Organisation du dépôt

```text
.
├── Dockerfile
├── compose.yml
├── README.md
├── GUIDE_REDACTION.md
├── LICENSE-CODE
├── LICENSE-CONTENT
├── scripts
│   ├── _schema.py
│   ├── check-content.py
│   ├── new-content.py
│   └── update-content.py
└── src
    ├── content
    ├── sass
    ├── static
    ├── templates
    └── zola.toml
```

- `src/content/` contient les pages Markdown ;
- `src/templates/` contient les templates Tera ;
- `src/sass/main.scss` contient les styles ;
- `src/static/` contient les ressources servies telles quelles ;
- `src/zola.toml` contient la configuration de Zola ;
- `scripts/` contient les outils de création, de mise à jour et de validation des contenus.

## Déploiement avec Docker Compose

L’image est construite en trois étapes : validation des contenus, construction avec Zola 0.22.1, puis service des seuls fichiers statiques.

Vérifier la configuration :

```sh
docker compose config
```

Construire et lancer le service :

```sh
docker compose up -d --build
```

Consulter son état et ses journaux :

```sh
docker compose ps
docker compose logs --tail=100 zola
```

Le service écoute uniquement sur l’interface locale de l’hôte :

```text
http://127.0.0.1:8002
```

Le domaine public et le certificat TLS sont pris en charge par un proxy inverse placé devant le conteneur.

Mettre à jour le déploiement :

```sh
git pull --ff-only
docker compose up -d --build
```

Arrêter le service :

```sh
docker compose down
```

## Licences

Le code propre au projet est distribué sous licence MIT ; voir [`LICENSE-CODE`](LICENSE-CODE).

Sauf mention contraire, les contenus originaux de `src/content/` sont publiés sous licence CC BY-SA 4.0 ; voir [`LICENSE-CONTENT`](LICENSE-CONTENT).

Les polices, photographies et autres ressources tierces restent soumises à leurs propres droits et licences.