Module:Ligne apparition

Documentation module[créer]

local p = {}

local Episode = require("Module:Episode")

----------------------------------------------------------------------
-- 1) Nettoyage UTF‑8 (anti-crash)
----------------------------------------------------------------------
local function safe_utf8(str)
    if type(str) ~= "string" then
        return ""
    end
    return mw.ustring.gsub(str, "[^\0-\x7F\xC2-\xF4][\x80-\xBF]*", " ")
end

----------------------------------------------------------------------
-- 2) Normalisation avancée
----------------------------------------------------------------------
local function normalize(str)
    str = safe_utf8(str or "")
    str = mw.text.trim(str)
    str = mw.ustring.lower(str)
    str = str:gsub("[%-%_]", " ")
    str = mw.ustring.toNFD(str)
    str = str:gsub("[%pM]", "")
    str = str:gsub("%s+", " ")
    return str
end

----------------------------------------------------------------------
-- 3) Table des types (Type d’apparition → propriété SMW)
----------------------------------------------------------------------
local types = {
    main = "Personnage principal de ",
    ["main character"] = "Personnage principal de ",
    m = "Personnage principal de ",
    p = "Personnage principal de ",
    principal = "Personnage principal de ",

    supporting = "Personnage secondaire de ",
    ["supporting character"] = "Personnage secondaire de ",
    s = "Personnage secondaire de ",
    su = "Personnage secondaire de ",
    se = "Personnage secondaire de ",
    secondaire = "Personnage secondaire de ",

    recurring = "Personnage récurrent de ",
    re = "Personnage récurrent de ",
    ["recurring character"] = "Personnage récurrent de ",
    recurrent = "Personnage récurrent de ",

    ["one shot"] = "Personnage one shot de ",
    ["one-shot"] = "Personnage one shot de ",
    ["one shot character"] = "Personnage one shot de ",
    os = "Personnage one shot de ",

    minor = "Personnage mineur de ",
    mi = "Personnage mineur de ",
    ["minor character"] = "Personnage mineur de ",
    mineur = "Personnage mineur de ",

    yes = "Apparaît dans ",
    ['true'] = "Apparaît dans ",
    y = "Apparaît dans ",
    t = "Apparaît dans ",
    o = "Apparaît dans ",
    oui = "Apparaît dans ",
    v = "Apparaît dans ",
    vrai = "Apparaît dans ",

    mention = "Mentionné dans ",
    me = "Mentionné dans ",
    men = "Mentionné dans ",
    mentioned = "Mentionné dans ",

    picture = "Photo seule dans ",
    photo = "Photo seule dans ",

    voice = "Voix seule dans ",
    voix = "Voix seule dans ",

    body = "Corps visible dans ",
    corpse = "Corps visible dans ",
    corps = "Corps visible dans ",

    ["deleted scenes"] = "Apparaît uniquement dans les scènes supprimées de ",
    del = "Apparaît uniquement dans les scènes supprimées de ",
    sup = "Apparaît uniquement dans les scènes supprimées de ",
    supp = "Apparaît uniquement dans les scènes supprimées de ",

    flash = "Apparaît uniquement dans des flashbacks de ",
    flashback = "Apparaît uniquement dans des flashbacks de ",

    name = "Nom visible dans ",
    nom = "Nom visible dans ",

    ["#default"] = "Apparaît dans "
}

local function appearancePropertyLabel(typeApp)
    local key = normalize(typeApp)
    return types[key] or types["#default"]
end

----------------------------------------------------------------------
-- 4) Alias → catégories (Marquage type d’apparition)
----------------------------------------------------------------------
local alias = {
    m="principal", main="principal", ["main character"]="principal",
    p="principal", principal="principal", ["personnage principal"]="principal",

    s="secondaire", su="secondaire", supporting="secondaire",
    ["supporting character"]="secondaire", se="secondaire",
    secondaire="secondaire", ps="secondaire",

    re="recurrent", recurring="recurrent",
    ["recurring character"]="recurrent", recurrent="recurrent",

    os="oneshot", ["one shot"]="oneshot",
    ["one-shot"]="oneshot", ["one shot character"]="oneshot",

    mi="mineur", minor="mineur",
    ["minor character"]="mineur", mineur="mineur",

    y="true", yes="true", t="true", ["true"]="true",
    o="true", oui="true", v="true", vrai="true",

    me="mention", men="mention", mention="mention",
    mentioned="mention", mentionne="mention",

    picture="photo", photo="photo",

    voice="voix", voix="voix", ["voix seule"]="voix",

    body="corps", corpse="corps", corps="corps", cadavre="corps",

    del="deleted", ["deleted scenes"]="deleted",
    sup="deleted", supp="deleted",
    ["scene supprimee"]="deleted",
    ["scenes supprimees"]="deleted",

    flash="flashback", flashback="flashback",

    name="nom", nom="nom"
}

local messages = {
    principal="", secondaire="", recurrent="", oneshot="", mineur="", ["true"]="",
    mention=" (mention)", photo=" (photo seule)", voix=" (voix seule)",
    deleted=" (scenes supprimees)", flashback=" (flashbacks)",
    nom=" (nom uniquement)", corps=" (corps)"
}

----------------------------------------------------------------------
-- 5) Génère le suffixe brut (sans italique)
----------------------------------------------------------------------
local function appearanceSuffix(typeApp, epLink, deathLink)
    local norm = normalize(typeApp)
    local key = alias[norm]
    local isDead = (epLink == deathLink and epLink ~= "")

    -- Type vide → (décédé) si mort
    if norm == "" then
        if isDead then return " (décédé)" end
        return ""
    end

    -- Alias inconnu → même logique
    if not key then
        if isDead then return " (décédé)" end
        return ""
    end

    -- Type connu
    local base = messages[key] or ""

    if isDead then
        return base:gsub("%)$", ", décédé)")
    end

    return base
end

----------------------------------------------------------------------
-- 6) Transforme le suffixe brut en suffixe affiché (italique)
----------------------------------------------------------------------
local function buildDisplaySuffix(rawSuffix)
    if rawSuffix == "" then return "" end
    return " ''" .. rawSuffix .. "''"
end

----------------------------------------------------------------------
-- 7) Enregistre le nom du personnage dans l’épisode (SMW)
----------------------------------------------------------------------
local function setCharacterName(ep, name)
    if ep == "" or name == "" then return "" end
    local fullName = Episode.getEpisodeTitle{ args = { ep } }
    if not fullName or fullName == "" then return "" end
    return string.format("{{#set: Nom du personnage dans %s = %s}}", fullName, name)
end

----------------------------------------------------------------------
-- 8) Fonction principale
----------------------------------------------------------------------
function p.main(frame)
    local args = frame.args

    local ep      = safe_utf8(args[1] or "")
    local typeApp = safe_utf8(args[2] or "")
    local order   = safe_utf8(args[3] or "")
    local name    = safe_utf8(args[4] or "")
    local deathEp = safe_utf8(args[5] or "")

    if ep == "" then return "" end

    local linkFull  = Episode.getEpisodeFullLink{ args = { ep } }
    local linkTitle = Episode.getEpisodeTitle{ args = { ep } }
    local linkShort = Episode.getEpisodeLink{ args = { ep } }

    ------------------------------------------------------------------
    -- Conversion automatique du paramètre 5 (titre → code d’épisode)
    ------------------------------------------------------------------
    local deathLink = Episode.getEpisodeLink{ args = { deathEp } }

	if deathLink == "" then
	    -- On récupère le lien complet depuis le titre
	    local deathFull = Episode.getEpisodeFullLink{ args = { deathEp } }
	
	    -- Puis on convertit ce lien complet en code d’épisode
	    deathLink = Episode.getEpisodeLink{ args = { deathFull } }
	end

    local isDead = (deathLink == linkShort and deathLink ~= "")

    ------------------------------------------------------------------
    -- Suffixe affiché
    ------------------------------------------------------------------
    local rawSuffix = appearanceSuffix(typeApp, linkShort, deathLink)
    local suffix = buildDisplaySuffix(rawSuffix)

    ------------------------------------------------------------------
    -- Affichage principal
    ------------------------------------------------------------------
    local propLabel = appearancePropertyLabel(typeApp)

    local display
    if typeApp ~= "" then
        display = string.format("'''[[%s::%s|%s]]'''%s",
            propLabel, linkFull, linkTitle, suffix)
    else
        display = string.format("<span style=\"color:#555555;\">%s</span>%s",
            linkTitle, suffix)
    end

    ------------------------------------------------------------------
    -- SMW (invisible) via preprocess
    ------------------------------------------------------------------
    local smw = ""

    if isDead then
        smw = smw .. string.format("{{#set: Décédé dans = %s}}", linkFull)
    end

    if order ~= "" then
        smw = smw .. string.format("{{#set: Ordre d'apparition dans %s = %s}}",
            linkShort, order)
    end

    if name ~= "" then
        smw = smw .. setCharacterName(ep, name)
    end

    if smw ~= "" then
        frame:preprocess(smw)
    end

    return display
end

return p