Nicht angemeldeter Benutzer - Bearbeiten von Seiten ist nur als angemeldeter Benutzer möglich.
Modul:Vorlage:Literatur: Unterschied zwischen den Versionen
Zur Navigation springen
Zur Suche springen
(2016-02-10) |
(2016-05-18) |
||
Zeile 1: | Zeile 1: | ||
− | --[=[ | + | local Serial = "2016-05-18" |
+ | --[=[ | ||
Unterstützung für {{Literatur}} | Unterstützung für {{Literatur}} | ||
]=] | ]=] | ||
Zeile 44: | Zeile 45: | ||
Spalten = true, | Spalten = true, | ||
ArtikelNr = true, | ArtikelNr = true, | ||
+ | Fundstelle = true, | ||
ISBN = true, | ISBN = true, | ||
ISBNformalFalsch = { ISBNistFormalFalsch=true }, | ISBNformalFalsch = { ISBNistFormalFalsch=true }, | ||
Zeile 99: | Zeile 101: | ||
Spalten = { "fragment", "Spalten" }, | Spalten = { "fragment", "Spalten" }, | ||
ArtikelNr = { "fragment", "ArtikelNr" }, | ArtikelNr = { "fragment", "ArtikelNr" }, | ||
+ | Fundstelle = { "fragment", "Fundstelle" }, | ||
ISBN = { "id", "ISBN" }, | ISBN = { "id", "ISBN" }, | ||
ISBNformalFalsch = { "id", "ISBNfalsch" }, | ISBNformalFalsch = { "id", "ISBNfalsch" }, | ||
Zeile 269: | Zeile 272: | ||
if args.Monat:match( "%l" ) then | if args.Monat:match( "%l" ) then | ||
local dm = DateTime( args.Monat ) | local dm = DateTime( args.Monat ) | ||
− | if dm.month then | + | if dm and dm.month then |
o.month = dm.month | o.month = dm.month | ||
else | else | ||
Zeile 348: | Zeile 351: | ||
args.ISBNformalFalsch = args.ISBN | args.ISBNformalFalsch = args.ISBN | ||
args.ISBN = nil | args.ISBN = nil | ||
− | + | elseif args.ISBNistFormalFalsch ~= "" then | |
fehler( "Parameter", | fehler( "Parameter", | ||
"Überflüssig: 'ISBNistFormalFalsch' ohne 'ISBN'" ) | "Überflüssig: 'ISBNistFormalFalsch' ohne 'ISBN'" ) | ||
Zeile 422: | Zeile 425: | ||
function p.f( frame ) | function p.f( frame ) | ||
local lucky, r = pcall( f, frame:getParent().args, frame ) | local lucky, r = pcall( f, frame:getParent().args, frame ) | ||
+ | if not lucky then | ||
+ | fehler( "Intern", r ) | ||
+ | r = fehlerliste() | ||
+ | end | ||
return r | return r | ||
+ | end | ||
+ | |||
+ | function p.failsafe() | ||
+ | return Serial | ||
end | end | ||
return p | return p |
Version vom 18. Mai 2016, 16:49 Uhr
Vorlagenprogrammierung | Diskussionen | Lua | Unterseiten | ||
Modul | Deutsch
|
Modul: | Dokumentation |
Diese Seite enthält Code in der Programmiersprache Lua. Einbindungszahl Cirrus |
Dieses Modul (und die Dokumentation) basieren (teilweise) auf Modul:Vorlage:Literatur aus der freien Enzyklopädie Wikipedia und steht unter der GNU Lizenz für freie Dokumentation und der Creative Commons Attribution/Share Alike. Auf Wikipedia ist eine Liste der Autoren verfügbar. Weiteres zum Import aus Wikipedia siehe Seite Imedwiki:Import aus Wikipedia.
local Serial = "2016-05-18"
--[=[
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" },
ISBNistFormalFalsch = { s = "/Parameter ISBNistFormalFalsch" },
TitelP = { s = "/Parameter Titel-P" }
}
local ParValid = {
Autor = { Autorin=true,
Autoren=true,
Autorinnen=true },
Herausgeber = { Hrsg=true,
Herausgeberin=true },
Titel = { ["Titel-P"] = { low=true } },
TitelErg = true,
Sammelwerk = true,
WerkErg = true,
Reihe = true,
BandReihe = true,
HrsgReihe = true,
NummerReihe = true,
Band = true,
Nummer = true,
Auflage = true,
Verlag = true,
Ort = true,
Datum = true,
Jahr = { Datum=true },
Monat = { Datum=true,
Woche=true },
Woche = { Datum=true },
Tag = { Datum=true,
Woche=true },
Kapitel = true,
Seiten = true,
Spalten = true,
ArtikelNr = true,
Fundstelle = true,
ISBN = true,
ISBNformalFalsch = { ISBNistFormalFalsch=true },
ISBNistFormalFalsch = true,
ISSN = true,
Umfang = true,
Sprache = true,
Kommentar = true,
Originaltitel = true,
Originalsprache = true,
Originalort = true,
Originaljahr = true,
["Übersetzer"] = { ["Übersetzerin"]=true },
VerlagEA = true,
OrtEA = true,
JahrEA = true,
arXiv = { Arxiv = { low=true } },
bibcode = true,
DOI = true,
DNB = true,
JSTOR = true,
LCCN = true,
OCLC = true,
PMC = true,
PMID = true,
URN = true,
ZDB = true,
ID = true,
Online = true,
Abruf = { Zugriff = { low=true } },
Format = true,
KByte = true,
Zitat = true,
Typ = true,
Vorlage = true }
local ParMap = {
Autor = { "bas", "Autor" },
Herausgeber = { "bas", "Hrsg" },
Titel = { "bas", "Titel" },
TitelErg = { "bas", "TitelErg" },
Sammelwerk = { "bas", "Werk" },
WerkErg = { "bas", "WerkErg" },
Reihe = { "serie", "Reihe" },
BandReihe = { "serie", "Band" },
HrsgReihe = { "serie", "Hrsg" },
NummerReihe = { "serie", "Nummer" },
Band = { "print", "Band" },
Nummer = { "print", "Nummer" },
Auflage = { "print", "Auflage" },
Verlag = { "bas", "Verlag" },
Ort = { "print", "Ort" },
Datum = { "bas", "Datum" },
Kapitel = { "fragment", "Kapitel" },
Seiten = { "fragment", "Seiten" },
Spalten = { "fragment", "Spalten" },
ArtikelNr = { "fragment", "ArtikelNr" },
Fundstelle = { "fragment", "Fundstelle" },
ISBN = { "id", "ISBN" },
ISBNformalFalsch = { "id", "ISBNfalsch" },
ISSN = { "id", "ISSN" },
Umfang = { "print", "Umfang" },
Sprache = { "bas", "Sprache" },
Kommentar = { "bas", "Kommentar" },
Zitat = { "bas", "Zitat" },
Originaltitel = { "orig", "Titel" },
Originalsprache = { "orig", "Sprache" },
["Übersetzer"] = { "orig", "Translator" },
OrtEA = { "ed1", "Ort" },
JahrEA = { "ed1", "Jahr" },
VerlagEA = { "ed1", "Verlag" },
Online = { "www", "Weblink" },
Abruf = { "www", "Abruf" },
Format = { "www", "Format" },
KByte = { "www", "KBytes" },
arXiv = { "id", "arXiv" },
bibcode = { "id", "bibcode" },
DOI = { "id", "DOI" },
DNB = { "id", "DNB" },
JSTOR = { "id", "JSTOR" },
LCCN = { "id", "LCCN" },
OCLC = { "id", "OCLC" },
PMC = { "id", "PMC" },
PMID = { "id", "PMID" },
URN = { "id", "URN" },
ZDB = { "id", "ZDB" },
ID = { "id", "ID" },
Typ = { "leise", "Typ" },
Vorlage = { "leise", "Vorlage" } }
local Fehler = false
local FunLit = { }
--|Lizenznummer nicht genutzt und nicht länger unterstützt
local function fault( a )
-- Formatiere Fehler mit class=error
-- Parameter:
-- a -- string mit Text
local r
if type( Zitation ) == "table" then
r = Zitation.fault( a )
else
r = string.format( "<span class=\"error\">%s</span>", a )
end
return r
end -- fault()
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" },
Vorlage = { s = "Vorlagen-Seite fehlt",
k = "Intern" },
Format = { s = "Parameterformat" },
Konflikt = { s = "Parameterkonflikt",
k = "Parameter" },
Parameter = { s = "Parameterfehler",
k = "Parameter" },
Pflicht = { s = "Pflichtparameter fehlt",
k = "Parameter" },
Wert = { s = "Werte ungültig",
k = "Parameter" },
Doppelt = { s = "Mehrfache Angabe von Parametern",
k = "Parameter" },
ISBNistFormalFalsch = { k = "ISBNistFormalFalsch" },
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
r = string.format( "%s%s*** %s: %s",
r, sep, v.s or "", v.e )
sep = " "
end
end -- for k, v
r = "<br />" .. fault( r )
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 Titel = function ( args )
-- OBSOLET nach Bereinigung im ANR
if args[ "Titel-P" ] then
fehler( "TitelP" )
end
end -- Titel()
FunLit.Datum = function ( args )
local r = args.Jahr
if r then
if r:match( "^%d+$" ) then
local DateTime = Zitation.fetch( "DateTime" )
local o = DateTime( r )
if args.Woche 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 dm.month then
o.month = dm.month
else
fehler( "Wert", "'Monat'=" .. args.Monat )
r = false
end
else
s = args.Monat:match( "^0?(1?%d)%.?$" )
if s then
o.month = tonumber( s )
end
if tostring( o.month ) ~= s then
fehler( "Wert", "'Monat'=" .. args.Monat )
r = false
elseif s ~= args.Monat then
fehler( "Format", "'Monat'=" .. args.Monat )
end
end
if 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
fehler( "Wert", "'Tag'=" .. args.Tag )
r = false
elseif s ~= args.Tag then
fehler( "Format", "'Tag'=" .. args.Tag )
end
end
elseif args.Tag then
fehler( "Konflikt", "'Tag' ohne 'Monat'" )
r = false
end
if r then
r = o
args.Datum = o
end
else
fehler( "Wert", "'Jahr'=" .. args.Jahr )
end
elseif args.Monat or args.Woche or args.Tag then
fehler( "Konflikt", "'Jahr' fehlt bei spezifischem Datum" )
else
r = args.Datum
end
return r
end -- FunLit.Datum()
local Band = function ( args )
if args.Reihe and
not args.BandReihe and
not args.Sammelwerk then
args.BandReihe = args.Band
args.Band = nil
end
end -- Band()
local Nummer = function ( args )
if args.Reihe and
not args.NummerReihe and
not args.Sammelwerk then
args.NummerReihe = args.Nummer
args.Nummer = nil
end
end -- Nummer()
FunLit.ISBN = function ( args )
-- OBSOLET nach Bereinigung im ANR
if args.ISBNistFormalFalsch then
if args.ISBN then
args.ISBNformalFalsch = args.ISBN
args.ISBN = nil
elseif args.ISBNistFormalFalsch ~= "" then
fehler( "Parameter",
"Überflüssig: 'ISBNistFormalFalsch' ohne 'ISBN'" )
end
args.ISBNistFormalFalsch = nil
fehler( "ISBNistFormalFalsch" )
end
end -- FunLit.ISBN()
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, ParValid )
local r, schrott
Titel( pars ) -- OBSOLET
FunLit.Datum( pars )
Band( pars )
Nummer( pars )
FunLit.ISBN( pars ) -- OBSOLET
Zitation.filler( pars, ParMap )
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
r = r .. Zitation.fault( schrott )
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
r = format( arglist )
else
fehler( "Modul", r )
end
return r .. fehlerliste()
end -- f()
-- Export
local p = {}
function p.export()
return { f = FunLit,
parMap = ParMap,
parValid = ParValid }
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
fehler( "Intern", r )
r = fehlerliste()
end
return r
end
function p.failsafe()
return Serial
end
return p