Comment créer un générateur de site statique avec Go

Les générateurs de sites statiques sont des outils puissants qui simplifient la création de sites Web légers, rapides et évolutifs. Que vous créiez des blogs, de la documentation ou des sites pour petites entreprises, ils transforment le contenu écrit en Markdown en fichiers HTML statiques et efficaces.

Dans ce guide, nous allons créer un Générateur de site statique (SSG) dans Go, un langage de programmation réputé pour ses performances, sa simplicité et sa concurrence. Nous allons créer un outil CLI qui prend les fichiers Markdown en entrée, les traite à l'aide d'un modèle HTML prédéfini et génère de belles pages HTML statiques.

---

Pourquoi construire ceci ?

Un générateur de site statique peut servir à plusieurs fins pratiques :

• Sites de documentation : générez des sites à chargement rapide pour la documentation technique.
• Blogs : rédigez votre contenu dans Markdown et déployez-le sans effort.
• Prototypage : créez rapidement des sites statiques pour de petits projets ou des vitrines.

Pourquoi utiliser Go pour ce projet ?

• Vitesse : Go compile en code machine natif, créant des outils comme celui-ci incroyablement rapides.
• Concurrency : Go facilite le traitement simultané de plusieurs fichiers.
• Simplicité : la syntaxe de Go est minimale et la création d'outils CLI est simple.

---

J'ai eu beaucoup de plaisir à construire ce projet :)

Configuration du projet

Avant de plonger dans le code, décrivons la structure du projet :

static-site-generator/
├── cmd/
│   └── ssg/
│       └── main.go           # Entry point
├── internal/
│   ├── generator/
│   │   └── html.go          # HTML generation logic
│   ├── parser/
│   │   ├── frontmatter.go   # YAML frontmatter parsing
│   │   └── markdown.go      # Markdown processing
│   └── watcher/
│       └── watcher.go       # File change detection
├── templates/
│   └── default.html         # HTML template
├── content/                 # Markdown files
└── output/

Si vous souhaitez construire à partir de zéro, exécutez cette commande pour initialiser un module Go pour le projet

go mod init

---

Principales caractéristiques :

• Convertir Markdown en HTML ?

• Principe YAML pour l'analyse des métadonnées

• Modèles HTML pour une sortie personnalisable

• Détection des modifications de fichiers en temps réel avec un observateur ?

Construire le projet

1. Cloner le référentiel

Avant de commencer, clonez le référentiel sur votre machine locale :

git clone https://github.com/Tabintel/static-site-generator.git
cd static-site-generator

Tabintel / générateur de site statique

Générateur de sites statiques

Un générateur de site statique rapide et simple écrit en Go.

Voir sur GitHub

Cela vous donnera tous les fichiers de démarrage et la structure du projet nécessaires pour créer et exécuter le SSG.

---

2. Analyseur de démarques

L'analyseur Markdown gère la conversion des fichiers .md en contenu HTML. Il permet également des fonctionnalités étendues telles que les identifiants de titre automatiques.

interne/parser/markdown.go

static-site-generator/
├── cmd/
│   └── ssg/
│       └── main.go           # Entry point
├── internal/
│   ├── generator/
│   │   └── html.go          # HTML generation logic
│   ├── parser/
│   │   ├── frontmatter.go   # YAML frontmatter parsing
│   │   └── markdown.go      # Markdown processing
│   └── watcher/
│       └── watcher.go       # File change detection
├── templates/
│   └── default.html         # HTML template
├── content/                 # Markdown files
└── output/

✨Convertit le contenu Markdown au format HTML avec prise en charge de fonctionnalités étendues.

---

3. Analyseur de frontmatière

L'analyseur de frontmatter extrait les métadonnées telles que le titre, la date, les balises et la description des fichiers Markdown.

interne/parser/frontmatter.go

go mod init

? Extrait et renvoie les métadonnées ainsi que le contenu du fichier Markdown.

---

4. Générateur HTML

Le générateur HTML utilise le package html/template de Go pour créer des pages HTML statiques basées sur un modèle.

interne/générateur/html.go

git clone https://github.com/Tabintel/static-site-generator.git
cd static-site-generator

? Génère des fichiers HTML à partir de modèles et de contenu Markdown analysé.

---

5. Observateur de fichiers

Notre observateur surveille le répertoire content/ pour détecter les modifications et déclenche automatiquement les reconstructions.

Ceci est construit en utilisant https://github.com/fsnotify/fsnotify

interne/watcher/watcher.go

package parser

import (
    "github.com/gomarkdown/markdown"
    "github.com/gomarkdown/markdown/parser"
)

type MarkdownContent struct {
    Content    string
    Title      string
    Date       string
    Tags       []string
    HTMLOutput string
}

func ParseMarkdown(content []byte) *MarkdownContent {
    extensions := parser.CommonExtensions | parser.AutoHeadingIDs
    parser := parser.NewWithExtensions(extensions)
    html := markdown.ToHTML(content, parser, nil)

    return &MarkdownContent{
        Content:    string(content),
        HTMLOutput: string(html),
    }
}

? Détecte les modifications de fichiers et automatise la régénération des fichiers statiques.

---

6. Application principale

Le point d'entrée relie tous les composants ensemble et fournit des options CLI pour la personnalisation.

cmd/ssg/main.go

package parser

import (
    "bytes"
    "gopkg.in/yaml.v2"
)

type Frontmatter struct {
    Title       string   `yaml:"title"`
    Date        string   `yaml:"date"`
    Tags        []string `yaml:"tags"`
    Description string   `yaml:"description"`
}

func ParseFrontmatter(content []byte) (*Frontmatter, []byte, error) {
    parts := bytes.Split(content, []byte("---"))
    if len(parts) < 3 {
        return nil, content, nil
    }

    var meta Frontmatter
    err := yaml.Unmarshal(parts[1], &meta)
    if err != nil {
        return nil, content, err
    }

    return &meta, bytes.Join(parts[2:], []byte("---")), nil
}

---

Usage

Avant d'exécuter l'application, créez un fichier markdown à l'aide de .md et enregistrez-le dans le répertoire de contenu

Ensuite, lancez le générateur :

package generator

import (
    "html/template"
    "os"
    "path/filepath"
)

type Generator struct {
    TemplateDir string
    OutputDir   string
}

func NewGenerator(templateDir, outputDir string) *Generator {
    return &Generator{
        TemplateDir: templateDir,
        OutputDir:   outputDir,
    }
}

func (g *Generator) Generate(data interface{}, outputFile string) error {
    if err := os.MkdirAll(g.OutputDir, 0755); err != nil {
        return err
    }

    tmpl, err := template.ParseFiles(filepath.Join(g.TemplateDir, "default.html"))
    if err != nil {
        return err
    }

    out, err := os.Create(filepath.Join(g.OutputDir, outputFile))
    if err != nil {
        return err
    }
    defer out.Close()

    return tmpl.Execute(out, data)
}

Il convertit le fichier markdown en fichier HTML et l'enregistre dans le répertoire de sortie

Comme vous pouvez le voir, il ajoute une mise en forme pour le rendre visuellement attrayant :)

Surveillez les changements

Activer l'observateur :

package watcher

import (
    "fmt"
    "github.com/fsnotify/fsnotify"
    "log"
    "os"
    "path/filepath"
)

type ProcessFn func() error

func Watch(dir string, process ProcessFn) error {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        return err
    }
    defer watcher.Close()

    done := make(chan bool)
    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                if event.Op&fsnotify.Write == fsnotify.Write {
                    fmt.Printf("Modified file: %s\n", event.Name)
                    if err := process(); err != nil {
                        log.Printf("Error processing: %v\n", err)
                    }
                }
            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                log.Printf("Error: %v\n", err)
            }
        }
    }()

    err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if info.IsDir() {
            return watcher.Add(path)
        }
        return nil
    })
    if err != nil {
        return err
    }

    <-done
    return nil
}

---

Et c'est tout !

Ce SSG convertit le markdown en HTML propre, surveille les changements et maintient votre contenu organisé. Déposez un commentaire si vous construisez quelque chose avec - j'aimerais voir ce que vous créez !

Vous avez trouvé cela utile ? Vous pouvez m'offrir un café pour soutenir davantage de tutoriels Go ! ☕

Bon codage ! ?

Tabintel / générateur de site statique

Générateur de sites statiques

Un générateur de site statique rapide et simple écrit en Go.

Voir sur GitHub

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!