Espace Codage

Modèle Constructeur · Builder Pattern

Visualisation de l'espace de codage et implémentation du pattern Builder pour créer un ProjetEspaceCodage étape par étape.

Espace Codage

Vue conceptuelle des outils : éditeur, terminal, build, tests, déploiement…

SCHEMA

Cliquez sur un nœud pour voir une info rapide. Utilisez les boutons de démonstration ci-dessous pour simuler la construction.

Code · Builder Pattern

Implémentation en Python du pattern Builder pour un ProjetEspaceCodage complexe.

Builder Pattern Objet complexe Python Espace Codage

BUILDER

espace_codage_builder.py · Python

# === ESPACE CODAGE · MODÈLE CONSTRUCTEUR (BUILDER) ===
# Situation :
# - on veut créer un "objet complexe" ProjetEspaceCodage
#   indépendamment de la manière dont chaque partie est construite.
# - différents Builders produisent différentes représentations
#   (projet minimal, projet full‑stack, etc.).

from abc import ABC, abstractmethod
from typing import List, Dict


class ProjetEspaceCodage:
    """Produit complexe : représente l'espace de codage complet."""

    def __init__(self, nom: str = "Nouveau Projet") -> None:
        self.nom = nom
        self.composants: List[str] = []
        self.configurations: Dict[str, str] = {}
        self.etapes: List[str] = []

    def ajouter_composant(self, description: str) -> None:
        self.composants.append(description)

    def ajouter_configuration(self, cle: str, valeur: str) -> None:
        self.configurations[cle] = valeur

    def ajouter_etape(self, etape: str) -> None:
        self.etapes.append(etape)

    def decrire(self) -> None:
        print(f"=== ESPACE CODAGE : {self.nom} ===")
        print("Composants :")
        for i, comp in enumerate(self.composants, 1):
            print(f"  {i}. {comp}")

        if self.configurations:
            print("Configurations :")
            for cle, val in self.configurations.items():
                print(f"  • {cle}: {val}")

        if self.etapes:
            print("Étapes de construction :")
            for etape in self.etapes:
                print(f"  → {etape}")


class ConstructeurEspaceCodage(ABC):
    """Interface d'assemblage & construction."""

    def __init__(self, nom_projet: str) -> None:
        self.projet = ProjetEspaceCodage(nom_projet)

    @abstractmethod
    def configurer_documentation(self) -> None: pass

    @abstractmethod
    def configurer_editeur(self) -> None: pass

    @abstractmethod
    def configurer_terminal_debugger(self) -> None: pass

    @abstractmethod
    def configurer_build_system(self) -> None: pass

    @abstractmethod
    def configurer_tests(self) -> None: pass

    @abstractmethod
    def configurer_deploiement(self) -> None: pass

    def obtenir_projet(self) -> ProjetEspaceCodage:
        return self.projet

    def operation_optionnelle(self) -> None: pass


class ConstructeurMinimal(ConstructeurEspaceCodage):

    def configurer_documentation(self) -> None:
        self.projet.ajouter_composant("Documentation : README.md simple")
        self.projet.ajouter_etape("Documentation minimale configurée")

    def configurer_editeur(self) -> None:
        self.projet.ajouter_composant("Code Editor : VS Code avec thème par défaut")
        self.projet.ajouter_configuration("editor.theme", "default-dark")
        self.projet.ajouter_etape("Éditeur de code configuré")

    def configurer_terminal_debugger(self) -> None:
        self.projet.ajouter_composant("Terminal intégré + debug minimal (print)")
        self.projet.ajouter_etape("Terminal et debugger basique configurés")

    def configurer_build_system(self) -> None:
        self.projet.ajouter_composant("Build System : exécution directe du script")
        self.projet.ajouter_etape("Système de build minimal configuré")

    def configurer_tests(self) -> None:
        self.projet.ajouter_composant("Tests : quelques tests manuels")
        self.projet.ajouter_etape("Tests manuels configurés")

    def configurer_deploiement(self) -> None:
        self.projet.ajouter_composant("Déploiement : exécution locale seulement")
        self.projet.ajouter_configuration("deployment.target", "local")
        self.projet.ajouter_etape("Déploiement local configuré")


class ConstructeurFullStack(ConstructeurEspaceCodage):

    def configurer_documentation(self) -> None:
        self.projet.ajouter_composant("Documentation : wiki, UML, API complète")
        self.projet.ajouter_configuration("docs.format", "OpenAPI + Markdown")
        self.projet.ajouter_etape("Documentation complète configurée")

    def configurer_editeur(self) -> None:
        self.projet.ajouter_composant("Code Editor : IDE complet + plugins")
        self.projet.ajouter_configuration("editor.plugins", "lint, format, refactor, git, ...")
        self.projet.ajouter_etape("Éditeur avancé configuré")

    def configurer_terminal_debugger(self) -> None:
        self.projet.ajouter_composant("Terminal multi‑onglets + debugger graphique")
        self.projet.ajouter_configuration("debugger.features", "breakpoints, watch, stack, step-by-step")
        self.projet.ajouter_etape("Terminal et debugger avancés configurés")

    def configurer_build_system(self) -> None:
        self.projet.ajouter_composant("Build System : pipeline CI/CD automatisé")
        self.projet.ajouter_configuration("build.pipeline", "tests → build → packaging → deployment")
        self.projet.ajouter_etape("Système de build avancé configuré")

    def configurer_tests(self) -> None:
        self.projet.ajouter_composant("Testing Framework : unitaires, intégration, e2e")
        self.projet.ajouter_configuration("testing.coverage", ">= 90%")
        self.projet.ajouter_etape("Framework de tests complet configuré")

    def configurer_deploiement(self) -> None:
        self.projet.ajouter_composant("Déploiement : CI/CD vers staging/production (cloud)")
        self.projet.ajouter_configuration("deployment.providers", "AWS, Docker, Kubernetes")
        self.projet.ajouter_etape("Déploiement cloud configuré")

    def operation_optionnelle(self) -> None:
        self.projet.ajouter_composant("Analyse statique + métriques + revues automatisées")
        self.projet.ajouter_configuration("quality.metrics", "complexité, dette technique, vulnérabilités")
        self.projet.ajouter_etape("Analyses avancées configurées (optionnel)")


class DirecteurEspaceCodage:
    """Le Directeur orchestre les étapes de construction."""

    def __init__(self, builder: ConstructeurEspaceCodage) -> None:
        self._builder = builder

    def construire_espace_codage(self) -> ProjetEspaceCodage:
        self._builder.configurer_documentation()
        self._builder.configurer_editeur()
        self._builder.configurer_terminal_debugger()
        self._builder.configurer_build_system()
        self._builder.configurer_tests()
        self._builder.configurer_deploiement()
        self._builder.operation_optionnelle()
        return self._builder.obtenir_projet()


if __name__ == "__main__":
    print("=== ESPACE CODAGE · PROJET MINIMAL ===")
    directeur = DirecteurEspaceCodage(ConstructeurMinimal("Script Python Simple"))
    projet_min = directeur.construire_espace_codage()
    projet_min.decrire()

    print("=== ESPACE CODAGE · PROJET FULL‑STACK ===")
    directeur = DirecteurEspaceCodage(ConstructeurFullStack("Application Web Avancée"))
    projet_full = directeur.construire_espace_codage()
    projet_full.decrire()

Démonstration du Builder Pattern

DEMO

Prêt à construire un espace de codage…

Note : Le modèle Constructeur se concentre sur un seul objet complexe (ProjetEspaceCodage) construit étape par étape. Une Abstract Factory fournirait plusieurs familles d’objets (éditeur, terminal, debugger, …) sans orchestrer le processus de construction comme le fait le DirecteurEspaceCodage.

Mes Tâches

IA Génératrice (Rosalinda)

Modèle Constructeur · Builder Pattern

Espace Codage

Code · Builder Pattern

Démonstration du Builder Pattern