Modul:Vorlage:Literatur

Vorlagenprogrammierung	Diskussionen	Lua		Unterseiten
		Modul	Deutsch	Modul:	Dokumentation

Diese Seite enthält Code in der Programmiersprache Lua. Einbindungszahl Cirrus

Neu erstellen

---

local Serial = "2019-06-11"
--[=[
Unterstützung für {{Literatur}}
]=]


-- Global
local Zitation
local Selbst = "Vorlage:Literatur"
local KategorieBeginn  =  "Wikipedia:Vorlagenfehler"
local Kategorien       =
                 { Intern              = { s = "/Interner Fehler" },
                   Parameter           = { s = "/Parameterfehler" },
                   MonatTag            = { s = "/Parameter Monat, Tag" },
                   Temp1               = { s = "/Temp1" },
                   Temp2               = { s = "/Temp2" },
                   Temp3               = { s = "/Temp3" },
                   Temp4               = { s = "/Temp4" },
                 }
local Fehler = false
local Schrei
local Export = { }



local function fehler( art, anzeige )
    -- Ein Fehler ist aufgetreten
    -- Parameter:
    --     art      -- string mit Schlüsselwort zum Typ
    --     anzeige  -- string mit Einzelheiten, oder nil
    local t
    if not Fehler then
        Fehler = { Intern    = { s = "Interner Fehler",
                                 k = "Intern" },
                   Modul     = { s = "Modul-Seite fehlt",
                                 k = "Intern" },
                   Format    = { s = "Parameterformat" },
                   Konflikt  = { s = "Parameterkonflikt",
                                 k = "Parameter" },
                   Parameter = { s = "Parameterfehler",
                                 k = "Parameter" },
                   Wert      = { s = "Werte ungültig",
                                 k = "Parameter" },
                   MonatTag  = { k = "MonatTag" },
                   Temp1     = { k = "Temp1" },
                   Temp2     = { k = "Temp2" },
                   Temp3     = { k = "Temp3" },
                   Temp4     = { k = "Temp4" }
                 }
    end
    t = Fehler[ art ]
    if t then
        if t.s  and  not t.e then
            t.e = ""
        end
        if anzeige then
            local s = mw.text.nowiki( anzeige )
            if t.e then
                t.e = string.format( "%s; %s", t.e, s )
            else
                t.e = s
            end
        end
        if t.k then
            local wk = Kategorien[ t.k ]
            if wk then
                wk.e = true
            else
                Fehler.Intern.e     = "Wartungskat " .. wk
                Kategorien.Intern.e = true
            end
        end
    else
        Fehler.Intern.e     = string.format( "fehler(%s) %s",
                                             art, anzeige or "???" )
        Kategorien.Intern.e = true
    end
end -- fehler()



local function fehlerliste()
    -- Auflistung aller Fehlermeldungen und Kategorien
    -- Rückgabewert: string mit formatiertem Ergebnis
    local r = ""
    local s
    if Fehler then
        local sep = ""
        local suffix
        for k, v in pairs( Fehler ) do
             if v.e then
                if v.e:sub( 1, 1 ) == ";" then
                    suffix = v.s .. v.e
                elseif v.s then
                    suffix = string.format( "%s: %s", v.s, v.e )
                else
                    suffix = v.e
                end
                Schrei = string.format( "%s%s*** %s",
                                        Schrei or "",
                                        sep,
                                        suffix )
                sep    = " "
            end
        end -- for k, v
    end
    for k, v in pairs( Kategorien ) do
        if v.e then
            if v.s:sub( 1, 1 ) == "/" then
                s = Selbst
            else
                s = ""
            end
            r = string.format( "%s[[Kategorie:%s/%s%s]]",
                               r, KategorieBeginn, s, v.s )
        end
    end -- for k, v
    return r
end -- fehlerliste()



local folder = function ()
    -- Parameter-Konfiguration laden
    local s = string.format( "Module:%s/params", Selbst )
    local lucky, params = pcall( mw.loadData, s )
    if type( params ) == "table" then
        Export.params = Export.flat( params )
    else
        error( string.format( "[[%s]] fehlt", s ) )
    end
end -- folder()



-------------------------------------------------------------------------



Export.flat = function ( adapt )
    -- Deep copy
    -- Parameter:
    --     adapt  -- something
    -- Returns atomic value, or deep copy of a table with no metatable
    local r
    if type( adapt ) == "table" then
        r = { }
        for k, v in pairs( adapt ) do
            r[ k ] = Export.flat( v )
        end -- for k, v
    else
        r = adapt
    end
    return r
end -- Export.flat()



Export.Datum = function ( args )
    local r = args.Jahr
    local shit
    if r then
        if r:match( "^%d+$" ) then
            local DateTime = Zitation.fetch( "DateTime" )
            local o = DateTime( r )
            if args.Woche and o then
                o.week = tonumber( args.Woche )
                if tostring( o.week ) ~= args.Woche then
                    fehler( "Wert", "'Woche'=" .. args.Woche )
                    r = false
                end
            elseif args.Monat then
                local s
                if args.Monat:match( "%l" ) then
                    local dm = DateTime( args.Monat )
                    if dm and o and dm.month then
                        o.month = dm.month
                    else
                        shit = "'Monat'=" .. args.Monat
                        if args.Nummer then
                            args.Nummer = string.format( "%s, %s",
                                                         args.Nummer,
                                                         args.Monat )
                        else
                            args.Nummer = args.Monat
                        end
                        if not args.Datum then
                            args.Datum = r
                        end
                        r = false
                    end
                else
                    s = args.Monat:match( "^0?(1?%d)%.?$" )
                    if s and o then
                        o.month = tonumber( s )
                    end
                    if o and tostring( o.month ) ~= s then
                        fehler( "MonatTag",  "'Monat'=" .. args.Monat )
                        r = false
                    elseif s ~= args.Monat  and
                           "0" .. s ~= args.Monat then
                        fehler( "MonatTag",  "'Monat'=" .. args.Monat )
                    end
                end
                if o and o.month  and  args.Tag then
                    s = args.Tag:match( "^0?([123]?%d)%.?$" )
                    if s then
                        o.dom = tonumber( s )
                    end
                    if tostring( o.dom ) ~= s then
                        shit = "'Tag'=" .. args.Tag
                        r = false
                    elseif s ~= args.Tag  and
                           "0" .. s ~= args.Tag  and
                           s .. "." ~= args.Tag then
                        fehler( "MonatTag",  "'Tag'=" .. args.Tag )
                    end
                end
            elseif args.Tag then
                shit = "'Tag' ohne 'Monat'"
                r = false
            end
            if r and o then
                r = o
                args.Datum = o
            end
        elseif r:match( "^%[%d%d%d%d%]$" ) then
            args.Datum = r:match( "^%[(%d+)%]$" )
            if args.Kommentar then
                args.Kommentar = ", " .. args.Kommentar
            else
                args.Kommentar = ""
            end
            args.Kommentar  = string.format( "o. J. %s%s",
                                             args.Jahr, args.Kommentar )
            fehler( "Wert", "'Datum'=o.J." )
        else
            if args.Datum then
                fehler( "Wert",  "'Jahr'=" .. args.Jahr )
            else
                args.Datum = args.Jahr
            end
        end
    elseif args.Monat or args.Woche or args.Tag then
        fehler( "Konflikt", "'Jahr' fehlt bei spezifischem Datum" )
    else
        r = args.Datum
    end
    if shit then
       fehler( "MonatTag", shit )
    end
    return r
end -- Export.Datum()



local Band = function ( args )
    --    OBSOLET   nach Bereinigung in allen NR
    if args.Band  and  not args.Sammelwerk then
        if args.Reihe  and  not args.BandReihe then
            args.BandReihe = args.Band
            args.Band      = nil
            fehler( "Temp4" )
            fehler( "Parameter", "Band= meint BandReihe=" )
        elseif args.Titel  and
               args.Titel:find( " In: " ) then
            fehler( "Parameter", "Band= ohne Sammelwerk=" )
        end
    end
end -- Band()



local Nummer = function ( args )
    --    OBSOLET   nach Bereinigung in allen NR
    if args.Nummer  and  not args.Sammelwerk then
        if args.Reihe  and  not args.NummerReihe then
            args.NummerReihe = args.Nummer
            args.Nummer      = nil
            fehler( "Temp4" )
            fehler( "Parameter", "Nummer= meint NummerReihe=" )
        elseif args.Titel  and
               args.Titel:find( " In: " ) then
            fehler( "Parameter", "Nummer= ohne Sammelwerk=" )
        end
    end
end -- Nummer()



local Herausgeber = function ( args )
    --    OBSOLET   nach Übernahme in Zentralmodul
    if args.Autor  and  args.Autor:find( "(Hrsg.)", 1, true ) then
        fehler( "Wert",
                "Autor= mit Klammer (Hrsg.); dafür Hrsg= verwenden" )
    end
end -- Herausgeber()



local Sprache = function ( args )
    --    OBSOLET   nach Bereinigung im Benutzerbereich
    if args.Originalsprache  and
       not args.Originaltitel  and
       not args["Übersetzer"]  and
       not args.Sprache then
        local t = mw.title.getCurrentTitle()
        if t.namespace == 2  or  t.namespace == 3 then
            args.Sprache         = args.Originalsprache
            args.Originalsprache = nil
            fehler( "Parameter",
                    "Sprache= nutzen statt Originalsprache="
                                                        .. args.Sprache )
            fehler( "Temp1" )
        end
    end
end -- Sprache()



local format = function ( args )
    -- Analysiere Argumente und bilde formatierte Zitation
    -- Parameter:
    --     args    -- table mit Vorlagenparametern
    -- Rückgabewert: string mit formatierter Zitation
    local pars = Zitation.filter( args, Export.params.valid )
    local r, schrott
    Export.Datum( pars )
    Herausgeber( pars )
    Band( pars )
    Nummer( pars )
    Sprache( pars )
    Zitation.filler( pars, Export.params.map )
    if Zitation.o then
        Zitation.fill( "leise",  "leiser",   true )
        Zitation.fill( "leise",  "Vorlage",  pars.Vorlage or Selbst )
        Zitation.o.coins = true
    end
    r, schrott = Zitation.format()
    if schrott then
        if Schrei then
            Schrei = string.format( "%s *** %s", Schrei, schrott )
        else
            Schrei = schrott
        end
    end
    return r
end -- format()



local function f( arglist, frame )
    -- Hauptfunktion zur Steuerung des Gesamtablaufs
    -- Parameter:
    --     arglist  -- table, mit Vorlagenparametern
    --     frame    -- object, oder nil
    -- Rückgabewert: string mit formatiertem Gesamtergebnis
    --                      einschließlich Fehlerliste und Kategorien
    local lucky, r = pcall( require, "Modul:Zitation" )
    if type( r ) == "table" then
        Zitation       = r.Zitation()
        Zitation.frame = frame
        folder()
        r = string.format( "%s%s%s",
                           format( arglist ),
                           fehlerliste(),
                           Zitation.failure( Schrei ) )
    else
        fehler( "Modul", r )
        r = fehlerliste()
    end
    return r
end -- f()



-- Export
local p = {}

function p.export()
    folder()
    return Export
end

function p.test( a )
    local lucky, r = pcall( f, a )
    return r
end

function p.f( frame )
    local lucky, r = pcall( f, frame:getParent().args, frame )
    if not lucky then
        mw.log( r )
        fehler( "Intern", r )
        r = fehlerliste()
    end
    return r
end

function p.failsafe()
    return Serial
end

return p