orgmode-to-gemini-blog/build_indexes.py

import argparse
import datetime
import os
import re
import shutil

from enrich_html import enrich_one_file
from website_config import configs_sites, global_config

# from enrich_html import static_page_path
# génère l'index gemini et html des articles rangés par langue

parser = argparse.ArgumentParser(description="Générer un site Web à partir de fichiers HTML.")
parser.add_argument("source", help="Le chemin vers le dossier contenant les fichiers HTML.")
args = parser.parse_args()

# Variables personnalisables
DOSSIER_SOURCE = 'sources/' + args.source  # Nom du dossier contenant les fichiers Markdown
FICHIER_INDEX = 'index_' + args.source  # Nom du fichier d'index à générer
TITRE_INDEX = f""
source_files_extension = "org"

config_title = configs_sites[args.source]['BLOG_TITLE']

# Expression régulière pour extraire la date et le slug du nom de fichier org
regex = r"^(\d{14})(-[a-zA-Z0-9_-]+)\.gmi$"
regex_orgroam = r"^(\d{14})_([a-zA-Z0-9_-]+)\.gmi$"

use_article_file_for_name = (not global_config["slug_with_year"])
website_name = args.source


def trouver_nom_article(fichier_org, format="html"):
    # print('fichier_org, ', fichier_org)
    with open(fichier_org, 'r') as file:
        lignes = file.readlines()

    nom_article = ''

    # print('trouver_nom_article format',format)
    # Expressions régulières pour trouver les titres de niveau 1 et 2
    if format == 'html':
        titre_niveau_1 = r'<h1\s+(?:id|data-created)="[^"]*">(.*?)</h1>'
        titre_niveau_2 = r'^\<h2.*?\>(.+)\<\/h2\>$'
    else:
        titre_niveau_1 = r'^\*+ (.+)$'
        titre_niveau_2 = r'^\*\*+ (.+)$'

    # Itérer sur les lignes du fichier
    for ligne in lignes:
        # Rechercher un titre de niveau 1
        titre_niveau_1_match = re.match(titre_niveau_1, ligne)
        if titre_niveau_1_match:
            titre_niveau_1_texte = titre_niveau_1_match.group(1)
            if titre_niveau_1_texte.lower() != "article" and titre_niveau_1_texte.lower() != "liens":
                nom_article = titre_niveau_1_texte
                break
            else:
                # Si le premier titre de niveau 1 est "Article", rechercher le premier titre de niveau 2
                titre_niveau_2_match = re.match(titre_niveau_2, ligne)
                if titre_niveau_2_match:
                    nom_article = titre_niveau_2_match.group(1)
                    break
    # print(f"Nom de l'article : {nom_article}")

    return nom_article.replace(args.source + '_', '').replace('_', ' ')


def find_year_and_slug(fichier):
    fichier = fichier.replace('..', '.')
    # print(f" ------------ build_indexes: find in {fichier} -------------")
    slug = fichier.replace('.gmi', '')
    annee = '2024'
    date_str = '2024-00-00'
    date = '2024-00-00'
    match = re.match(regex_orgroam, fichier)

    if match:
        date_str = match.group(1)
        annee = date_str[:4]
        slug = match.group(2)

    match = re.match(regex, fichier)
    if match:
        date_str = match.group(1)
        # Convertir la date en objet datetime
        if "-" in date_str:
            date = datetime.datetime.strptime(date_str, "%Y-%m-%d")
        else:
            date = datetime.datetime.strptime(date_str, "%Y%m%d%H%M%S")
        date_string_replaced = str(date).replace(' 00:00:00', '')
        slug = fichier.replace('.gmi', '')
        slug = slug.replace(date_string_replaced, '')
        slug = enlever_premier_tiret_ou_underscore(slug)

        annee = str(date.year).replace(' 00:00:00', '')
    # else:
    #     print('ERREUR aucun slug trouvé')

    # print(f" ------------ build_indexes:  ")
    # print(f" ------------ build_indexes: Fichier: {fichier}")
    # print(f" ------------ build_indexes: année: {annee}")
    # print(f" ------------ build_indexes: str(date): {str(date)}")
    # print(f" ------------ build_indexes: slug: {slug}")
    # print(f" ------------ build_indexes: chemin: {annee}/{slug}/")
    return [date_str, annee, slug]


def enlever_premier_tiret_ou_underscore(chaîne):
    if chaîne.startswith('-') or chaîne.startswith('_'):
        chaîne = chaîne[1:]
    return chaîne


# création des dossiers intermédiaires s'il y en a
# déplace le fichier dans le dossier spécifié
def create_path_folders_and_move_file(path, file):
    os.makedirs(os.path.dirname(path), exist_ok=True)

    shutil.move(file, path)


def get_files_list_of_folder(folder_path):
    # Vérifie si le dossier existe
    if not os.path.exists(folder_path):
        print(f" ------------ build_indexes: Erreur : Le dossier '{folder_path}' n'existe pas.")
        return
    # print('----------- get_files_list_of_folder: folder_path : ', folder_path)
    # Liste les fichiers articles, trie par nom décroissant
    try:
        fichiers_md = sorted([f.replace('.' + source_files_extension, '.gmi') for f in os.listdir(folder_path) if
                              f.endswith(source_files_extension)], reverse=True)
        print('fichiers trouvés:', len(fichiers_md))
        return fichiers_md
    except OSError as e:
        print(f" ------------ build_indexes: Erreur lors de la lecture du dossier : {e}")
        return


# transformer le nom du fichier orgmode en une création de dossier de l'année, et un sous dossier du nom du slug dans le nom de fichier, contenant un seul fichier d'index afin de faire de l'url rewrite en dur.
# le nom de fichier org commence par une date YYYY-MM-DD ou bien YYYYMMDDHHmmss, est suivie d'un slug, et finit par l'extension .org

def generer_index(dossier_source, fichier_index):
    # Chemin absolu du dossier parent (pour sauver le fichier d'index)
    dossier_parent = os.path.dirname(os.path.abspath(__file__))

    # Chemin complet du dossier contenant les Markdown
    chemin_dossier_source = os.path.join(dossier_parent, dossier_source)

    files_static = get_files_list_of_folder(chemin_dossier_source + '/')
    files_fr = get_files_list_of_folder(chemin_dossier_source + '/lang_fr')
    files_en = get_files_list_of_folder(chemin_dossier_source + '/lang_en')

    # Chemin complet pour le fichier d'index
    chemin_fichier_index_gemini = os.path.join(dossier_parent, 'gemini-capsules', args.source, 'index.gmi')
    chemin_fichier_index_html = os.path.join(dossier_parent, 'html-websites', args.source, 'index.html')

    print('\n index html: ', chemin_fichier_index_html)
    # Génère le contenu du fichier d'index
    contenu_index_gmi = f"{config_title}\n{'- ' * len(config_title)}\n\n"
    contenu_index_html = f"{config_title}\n{'- ' * len(config_title)}\n\n"

    contenu_index_gmi += "\n# Navigation\n-------------------------\n"
    contenu_index_html += "<h1>Navigation</h1>"
    for fichier in files_static:
        # print(" -------- fichier ", fichier)
        link_html = fichier.replace('.gmi', '.html')
        link_org = fichier.replace('.gmi', '.org')
        file_path_org = os.path.join(dossier_parent, "sources", website_name, link_org)
        article_name = trouver_nom_article(file_path_org, 'org')

        if article_name:
            contenu_index_gmi += f"=> {fichier} {article_name}\n"
        else:
            contenu_index_gmi += f"=> {fichier}\n"

        if fichier != "index.gmi":
            # print(' -------- rechercher le nom de l article dans le fichier ')
            if use_article_file_for_name:
                article_name = link_html
            else:
                article_name = trouver_nom_article(file_path_org, 'org')

            if not article_name:
                article_name = link_html
        else:
            article_name = 'Index'
        article_name = article_name.replace('_', ' ')
        contenu_index_html += f"<br><a href=/{link_html}>{article_name}</a>"

    # ne préciser la langue français que si on a des articles en Anglais
    if len(files_en):
        contenu_index_gmi += "\n# Articles en Français\n-------------------------\n"
    lang_folder = "lang_fr/"

    # ----------- indexer les articles en Français ------------------
    for fichier in files_fr:
        date_string, année, slug = find_year_and_slug(fichier)

        contenu_index_gmi += f"=> {fichier}\n"
        link_html = fichier.replace('.gmi', '.html')
        chemin_fichier_this_article_html = chemin_dossier_source + '/lang_fr/converted/' + link_html
        chemin_fichier_this_article_html = chemin_dossier_source + '/lang_fr/converted/' + link_html

        link_org = fichier.replace('.gmi', '.org')
        file_path_org = os.path.join(dossier_parent, "sources", website_name, lang_folder, link_org)
        article_name = trouver_nom_article(file_path_org, 'org')

        if not article_name:
            article_name = slug.replace('-', ' ')

        if global_config["slug_with_year"]:
            new_folder = f"{année}/{slug}"
            new_folder_path_this_article = os.path.join(dossier_parent,
                                                        'html-websites/' + args.source + '/' + new_folder + '/')

            # déplacer le fichier html dans le dossier slug,
            # et le renommer en index.html ensuite pour ne pas modifier l'index du blog
            contenu_index_html += f"<br><a href=/{année}/{slug}>{année} {article_name}</a>"
            os.makedirs(os.path.dirname(new_folder_path_this_article), exist_ok=True)
            shutil.copy(chemin_fichier_this_article_html, new_folder_path_this_article + 'index.html')
        else:
            contenu_index_html += f"<br><a href=/{lang_folder}/{link_html}>{link_html}</a>"

    # ---------------- pareil en anglais TODO
    # contenu_index_gmi += "\n# Articles in English\n-------------------------\n"
    # contenu_index_html += "<h1>Articles in English</h1>"
    # lang_folder="lang_en/"
    # for fichier in files_en:
    # ----------------------------------------

    print('chemin_fichier_index_html', chemin_fichier_index_html)
    print(' ')
    with open(chemin_fichier_index_html, 'w', encoding='utf-8') as file:
        print('contenu_index_html', contenu_index_html)
        contenu_index_html = enrich_one_file(contenu_index_html)
        file.write(contenu_index_html)
        print(f" ------------ build_indexes: Fichier d'index '{chemin_fichier_index_html}' généré avec succès.")

    # Écrit le contenu dans le fichier d'index
    try:
        with open(chemin_fichier_index_gemini, 'w', encoding='utf-8') as file:
            file.write(contenu_index_gmi)
            print(
                f" ------------ build_indexes: Fichier d'index gemini '{chemin_fichier_index_gemini}' généré avec succès.")

    except OSError as e:
        print(f" ------------ build_indexes: Erreur lors de l'écriture du fichier d'index : {e}")


if __name__ == "__main__":
    generer_index(DOSSIER_SOURCE, FICHIER_INDEX)