Module:Episode/index

Documentation module[créer]

local p = {}

-- List of source modules
local sources = {
	-- Stargate SG-1
    "Module:Episode/SG1Season1",
    "Module:Episode/SG1Season2",
    "Module:Episode/SG1Season3",
    "Module:Episode/SG1Season4",
    "Module:Episode/SG1Season5",
    "Module:Episode/SG1Season6",
    "Module:Episode/SG1Season7",
    "Module:Episode/SG1Season8",
    "Module:Episode/SG1Season9",
    "Module:Episode/SG1Season10",
    -- Stargate Atlantis
    "Module:Episode/SGASeason1",
    "Module:Episode/SGASeason2",
    "Module:Episode/SGASeason3",
    "Module:Episode/SGASeason4",
    "Module:Episode/SGASeason5",
    -- Stargate Universe
    "Module:Episode/SGUSeason1",
    "Module:Episode/SGUSeason2",
    -- Stargate Infinity
    "Module:Episode/SGISeason1",
    -- Stargate Origins
    "Module:Episode/SGOSeason1",
    -- Film and TV movies
    "Module:Episode/SGUMovies",
}

p.index = {}

------------------------------------------------------------
-- Normalization
------------------------------------------------------------

local function normalize(s)
    -- Default to empty string
    s = s or ""

    -- Trim leading/trailing whitespace
    s = mw.text.trim(s)

    -- Convert to NFD form (decomposed Unicode)
    -- This allows stripping accents by removing combining marks
    s = mw.ustring.toNFD(s)

    -- Remove combining diacritics (U+0300–U+036F)
    local combining_start = mw.ustring.char(0x0300)
    local combining_end   = mw.ustring.char(0x036F)
    s = mw.ustring.gsub(s, "[" .. combining_start .. "-" .. combining_end .. "]", "")

    -- Normalize apostrophes
    s = mw.ustring.gsub(s, "[’‘´`]", "'")

    -- Normalize curly quotes
    s = mw.ustring.gsub(s, "[“”]", "\"")

    -- Normalize all dash types to a simple hyphen
    s = mw.ustring.gsub(s, "[–—−]", "-")

    -- Collapse multiple spaces
    s = mw.ustring.gsub(s, "%s+", " ")

    -- Convert to lowercase
    s = mw.ustring.lower(s)

    return mw.text.trim(s)
end

------------------------------------------------------------
-- Alias variant generators + cache (FULL BLOCK)
------------------------------------------------------------

-- Remove all dash characters
local function alias_no_dash(a)
    return mw.ustring.gsub(a, "[-–—]", "")
end

-- Replace dash characters with spaces
local function alias_dash_to_space(a)
    return mw.ustring.gsub(a, "[-–—]", " ")
end

-- Cache global pour éviter de recalculer les variantes
local alias_cache = {}

local function get_variants(key)
    -- Retourne immédiatement si déjà calculé
    if alias_cache[key] then
        return alias_cache[key]
    end

    local variants = { key }

    -- Variante : suppression des tirets
    local nd = alias_no_dash(key)
    if nd ~= key then
        table.insert(variants, nd)
    end

    -- Variante : tirets remplacés par espaces
    local sp = alias_dash_to_space(key)
    if sp ~= key then
        table.insert(variants, sp)
    end

    -- Mise en cache
    alias_cache[key] = variants
    return variants
end

------------------------------------------------------------
-- Build the multi‑key index (optimized)
------------------------------------------------------------

for _, modname in ipairs(sources) do
    local ok, mod = pcall(require, modname)
    if ok and mod.episodes then

        local isMovieModule = modname:match("SGUMovies")

        for _, ep in ipairs(mod.episodes) do

            -- Clone pour éviter les mutations
            ep = mw.clone(ep)

            -- Ajustements films
            if isMovieModule then
                ep.namespace = ep.namespace or ""
                ep.season    = ep.season    or ""
                ep.episode   = ep.episode   or ""
            end

            -- Indexation des alias + variantes
            for _, key in ipairs(ep.alias or {}) do
                for _, raw in ipairs(get_variants(key)) do

                    local nkey = normalize(raw)

                    if p.index[nkey] then
                        mw.log(string.format(
                            "[EpisodeIndex] Alias collision detected: '%s' → %s and %s",
                            nkey,
                            p.index[nkey].id or "(no id)",
                            ep.id or "(no id)"
                        ))
                    else
                        p.index[nkey] = ep
                    end
                end
            end
        end
    end
end

------------------------------------------------------------
-- Access function
------------------------------------------------------------

function p.get(key)
    local ep = p.index[normalize(key)]
    if not ep then return nil end

    return {
        id          = ep.id,
        namespace   = ep.namespace,
        page_title  = ep.page_title,
        title_fr    = ep.title_fr,
        title_qc    = ep.title_qc,
        title_vo    = ep.title_vo,
        property    = ep.property,
        season      = ep.season,
        episode     = ep.episode,
    }
end

return p