feat: Add report generation module for tracking metadata changes

- Implemented `report.nim` to create structured reports on metadata modifications. - Added functionality to merge reports and convert them to formatted strings. docs: Create prompt documentation for Markdown parser project - Added `prompt.md` detailing the requirements and functionalities for the Markdown parser. - Included specifications, usage examples, and testing guidelines. docs: Generate code review report for Markdown parser - Created `rapport_revue_code.md` outlining security vulnerabilities, code quality issues, and suggested improvements. - Provided a detailed analysis of the codebase with actionable recommendations. test: Add test data for Markdown parser - Included various Markdown files and a JPG image in `test_data` to simulate different scenarios. - Ensured that the parser can handle both valid and invalid metadata. chore: Add version management file - Created `version.nim` for automatic versioning of the Markdown parser. - Established constants for major, minor, patch, and build versions.
2026-04-19 12:56:55 -04:00
commit 18ee8a1cfd
26 changed files with 3255 additions and 0 deletions
@@ -0,0 +1 @@
+Ce fichier simule une image JPG et devrait être ignoré par le parser.
@@ -0,0 +1,30 @@
+# Introduction à Nim
+
+Nim est un langage de programmation statiquement typé qui combine l'efficacité et la vitesse du C avec l'expressivité et la facilité d'utilisation de Python. Ce langage offre une syntaxe claire et élégante qui facilite l'écriture de code propre et maintenable.
+
+## Caractéristiques principales
+
+- **Compilation en C**: Nim se compile en C, ce qui lui permet d'être extrêmement rapide et portable.
+- **Typage statique**: Le système de type permet de détecter de nombreuses erreurs à la compilation.
+- **Gestion de la mémoire**: Nim offre un garbage collector mais permet aussi une gestion manuelle de la mémoire.
+- **Macros et méta-programmation**: Possibilité d'étendre le langage avec des macros puissantes.
+
+## Exemple de code
+
+```nim
+# Un exemple simple de code Nim
+import std/strformat
+
+type
+  Person = object
+    name: string
+    age: int
+
+proc greet(p: Person) =
+  echo fmt"Hello, {p.name}! You are {p.age} years old."
+
+let alice = Person(name: "Alice", age: 30)
+greet(alice)
+```
+
+Ce code montre la simplicité et l'élégance de Nim. La syntaxe est claire et les fonctionnalités sont puissantes.
@@ -0,0 +1,63 @@
+# La concurrence en Nim
+
+Nim offre plusieurs mécanismes pour gérer la concurrence et le parallélisme dans vos applications. Ces fonctionnalités permettent d'exploiter efficacement les processeurs multi-cœurs modernes.
+
+## Threads
+
+Nim supporte les threads natifs de l'OS via le module `threads`. 
+
+```nim
+import std/[threadpool]
+
+proc processData(data: int) {.thread.} =
+  echo "Processing data: ", data
+
+var threads: array[4, Thread[int]]
+for i in 0..3:
+  createThread(threads[i], processData, i)
+
+joinThreads(threads)
+```
+
+## ThreadPool
+
+Pour une gestion plus simple des tâches parallèles, Nim propose le module `threadpool`.
+
+```nim
+import std/[threadpool]
+
+proc calculateValue(x: int): int =
+  result = x * x
+
+var futures = newSeq[FlowVar[int]](10)
+for i in 0..9:
+  futures[i] = spawn calculateValue(i)
+
+for i in 0..9:
+  echo ^futures[i]
+```
+
+## Async/Await
+
+Pour la programmation asynchrone non bloquante, Nim offre le module `asyncdispatch`.
+
+```nim
+import std/[asyncdispatch, httpclient, strformat]
+
+proc fetchUrl(url: string) {.async.} =
+  let client = newAsyncHttpClient()
+  let response = await client.get(url)
+  echo fmt"Fetched {url}, size: {response.body.len} bytes"
+  client.close()
+
+proc main() {.async.} =
+  var fetches = @[
+    fetchUrl("https://nim-lang.org"),
+    fetchUrl("https://github.com/nim-lang/Nim")
+  ]
+  await all(fetches)
+
+waitFor main()
+```
+
+Ces fonctionnalités de concurrence font de Nim un excellent choix pour développer des applications hautes performances qui exploitent pleinement les capacités des processeurs modernes.
@@ -0,0 +1,50 @@
+---
+Date de création: 2024-02-15
+Heure de création: 09:30:22
+Date de modification: 2024-02-16
+Heure de modification: 14:15:36
+Author: Jean Dupont
+URL: https://nim-lang.org/docs/gc.html
+Lang: fr
+Catégorie: Documentation Technique
+---
+
+# Gestion de la mémoire en Nim
+
+Nim offre plusieurs stratégies de gestion de la mémoire qui peuvent être sélectionnées en fonction des besoins spécifiques de votre application. Cette flexibilité est l'un des grands avantages du langage.
+
+## Les différents garbage collectors
+
+### ARC (Automatic Reference Counting)
+
+ARC est le garbage collector par défaut depuis Nim 2.0. Il fonctionne en comptant les références à chaque objet et en libérant la mémoire dès qu'un objet n'a plus de références.
+
+```nim
+--gc:arc
+```
+
+### ORC (Owning Reference Counting)
+
+ORC est une amélioration d'ARC qui ajoute la gestion des références cycliques.
+
+```nim
+--gc:orc
+```
+
+### Mark & Sweep
+
+Le garbage collector traditionnel de Nim, qui parcourt périodiquement la mémoire pour identifier et libérer les objets non référencés.
+
+```nim
+--gc:refc
+```
+
+## Gestion manuelle de la mémoire
+
+Pour des applications nécessitant un contrôle très précis, Nim permet également une gestion manuelle de la mémoire.
+
+```nim
+--gc:none
+```
+
+Avec cette option, vous devez gérer vous-même l'allocation et la libération de la mémoire avec `alloc`, `dealloc`, etc.
@@ -0,0 +1,59 @@
+---
+Heure de création: 08:15:00
+Date de modification: 2024-03-12
+Author: Pierre Martin
+Catégorie: Développement Web
+Unknown: Cette métadonnée ne devrait pas être prise en compte
+---
+
+# Les frameworks Web en Nim
+
+Nim dispose de plusieurs frameworks web qui permettent de créer des applications web modernes et performantes. Voici un aperçu des options les plus populaires.
+
+## Jester
+
+Jester est un framework web minimaliste inspiré de Sinatra (Ruby). Il est simple à utiliser et parfait pour créer rapidement des applications web ou des API.
+
+```nim
+import jester, json
+
+routes:
+  get "/":
+    resp "Hello, World!"
+  
+  get "/api/users/@id":
+    let userId = @"id"
+    resp %*{"id": userId, "name": "User " & userId}
+```
+
+## Prologue
+
+Prologue est un framework web inspiré de Flask (Python) et de Tornado. Il offre un système de routage flexible, un moteur de templates, et d'autres fonctionnalités essentielles.
+
+```nim
+import prologue
+
+proc hello(ctx: Context) {.async.} =
+  resp "Hello, Prologue!"
+
+let app = newApp()
+app.addRoute("/", hello)
+app.run()
+```
+
+## Karax
+
+Karax est une bibliothèque pour créer des applications web côté client en Nim, similaire à React. Le code Nim est compilé en JavaScript.
+
+```nim
+import karax/[karaxdsl, vdom]
+
+proc createDom(): VNode =
+  result = buildHtml(tdiv):
+    h1: text "Hello, Karax!"
+    p: text "This is a Karax application"
+
+setRenderer createDom
+```
+
+Ces frameworks permettent aux développeurs Nim de créer des applications web complètes, des API RESTful ou des interfaces utilisateur dynamiques avec le langage qu'ils apprécient.
@@ -0,0 +1,23 @@
+# Idées de projets personnels
+
+Voici une liste d'idées de projets que je souhaite explorer dans les prochains mois :
+
+## Applications
+
+- **Gestionnaire de tâches** : Application simple mais efficace pour organiser mes tâches quotidiennes, avec des notifications et des rappels.
+- **Tracker de finances personnelles** : Outil pour suivre mes dépenses et mes revenus, avec des graphiques et des statistiques.
+- **Générateur de playlists** : Application qui crée des playlists basées sur mes goûts musicaux et mon humeur du jour.
+
+## Sites web
+
+- **Blog personnel** : Un site simple pour partager mes expériences et mes connaissances en développement.
+- **Portfolio en ligne** : Présentation de mes projets et de mes compétences pour les recruteurs potentiels.
+- **Plateforme de partage de recettes** : Site communautaire pour partager et découvrir des recettes de cuisine.
+
+## Jeux
+
+- **Jeu de plateforme 2D** : Un petit jeu de plateforme avec des niveaux générés procéduralement.
+- **Jeu de cartes multijoueur** : Adaptation d'un jeu de cartes classique pour jouer en ligne avec des amis.
+- **Clicker game** : Jeu simple mais addictif, avec des mécanismes de progression et d'amélioration.
+
+Ces projets me permettront d'explorer différentes technologies et de développer mes compétences dans divers domaines du développement informatique.
@@ -0,0 +1,56 @@
+---
+Date de création: 2024-03-10
+Heure de création: 10:45:30
+Date de modification: 
+Heure de modification: 
+Author: Marie Dubois
+URL: 
+Lang: fr
+Catégorie: 
+---
+
+# Optimisation de la compilation en Nim
+
+La compilation est une étape cruciale dans le développement de logiciels en Nim. Ce document explore les différentes options et techniques pour optimiser le processus de compilation et améliorer les performances de vos applications.
+
+## Options de compilation
+
+Nim offre plusieurs niveaux d'optimisation qui peuvent être spécifiés lors de la compilation :
+
+### Optimisation de base
+
+```
+nim c -d:release myprogram.nim
+```
+
+L'option `-d:release` active les optimisations de base, désactive les assertions et les vérifications de dépassement.
+
+### Optimisations avancées
+
+```
+nim c -d:release --opt:speed myprogram.nim
+```
+
+L'option `--opt:speed` optimise pour la vitesse d'exécution, tandis que `--opt:size` optimise pour la taille du binaire.
+
+## Compilation incrémentale
+
+La compilation incrémentale permet de réduire considérablement le temps de compilation lors du développement :
+
+```
+nim c --incremental myprogram.nim
+```
+
+Seuls les fichiers modifiés depuis la dernière compilation seront recompilés.
+
+## Compilation en parallèle
+
+Pour accélérer la compilation sur les machines multi-cœurs :
+
+```
+nim c --parallelBuild:4 myprogram.nim
+```
+
+Cette option utilise 4 cœurs pour compiler le projet en parallèle.
+
+Ces techniques peuvent significativement améliorer votre flux de travail de développement en Nim en réduisant les temps de compilation et en optimisant les performances de vos applications.
				`@@ -0,0 +1 @@`
				`Ce fichier simule une image JPG et devrait être ignoré par le parser.`