モジュール:Vorlage:Literatur

local Serial = "2017-05-04"
--=
Unterstützung für 
**
-- Global
local Zitation
local Selbst = "Vorlage:Literatur"
local KategorieBeginn  =  ""
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" },
TitelP              = { s = "/Parameter Titel-P" }
}
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" },
TitelP    = { k = "TitelP" }
}
end
t = Fehler art 
if t then
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 = ""
for k, v in pairs( Fehler ) do
if v.e then
Schrei = string.format( "%s%s*** %s: %s",
Schrei or "",
sep,
v.s or "",
v.e )
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( "%sKategorie:%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 Titel = function ( args )
--      --    OBSOLET   nach Bereinigung im ANR
--      if args "Titel-P"  then
--          fehler( "TitelP" )
--      end
--  end -- Titel()
local Band = function ( args )
--    OBSOLET   nach Bereinigung im ANR
if args.Band  and
not args.Sammelwerk  and  not args.BandReihe then
if args.Reihe then
args.BandReihe = args.Band
args.Band      = nil
fehler( "Temp4" )
end
end
end -- Band()
local Nummer = function ( args )
--    OBSOLET   nach Bereinigung im ANR
if args.Nummer  and
not args.Sammelwerk  and  not args.NummerReihe then
if args.Reihe then
args.NummerReihe = args.Nummer
args.Nummer      = nil
fehler( "Temp4" )
--      else
--          fehler( "Temp3" )
end
end
end -- Nummer()
local Herausgeber = function ( args )
--    OBSOLET   nach Bereinigung im ANR
if args.Hrsg  and
not args.Sammelwerk  and  not args.HrsgReihe then
if args.Reihe then
args.HrsgReihe = args.Hrsg
args.Hrsg      = nil
--          fehler( "Temp4" )
end
end
end -- Herausgeber()
local Sprache = function ( args )
--    OBSOLET   nach Bereinigung im ANR
if args.Originalsprache  and
not args.Originaltitel  and
not args"Übersetzer"  and
not args.Sprache then
args.Sprache         = args.Originalsprache
args.Originalsprache = nil
fehler( "Temp1" )
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
--  Titel( pars )    -- OBSOLET
Export.Datum( 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