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-05-19) |
(2016-05-19) |
||
Zeile 264: | Zeile 264: | ||
local DateTime = Zitation.fetch( "DateTime" ) | local DateTime = Zitation.fetch( "DateTime" ) | ||
local o = DateTime( r ) | local o = DateTime( r ) | ||
− | if args.Woche then | + | if args.Woche and o then |
o.week = tonumber( args.Woche ) | o.week = tonumber( args.Woche ) | ||
if tostring( o.week ) ~= args.Woche then | if tostring( o.week ) ~= args.Woche then | ||
Zeile 282: | Zeile 282: | ||
else | else | ||
s = args.Monat:match( "^0?(1?%d)%.?$" ) | s = args.Monat:match( "^0?(1?%d)%.?$" ) | ||
− | if s then | + | if s and o then |
o.month = tonumber( s ) | o.month = tonumber( s ) | ||
end | end | ||
− | if tostring( o.month ) ~= s then | + | if o and tostring( o.month ) ~= s then |
fehler( "Wert", "'Monat'=" .. args.Monat ) | fehler( "Wert", "'Monat'=" .. args.Monat ) | ||
r = false | r = false | ||
Zeile 292: | Zeile 292: | ||
end | end | ||
end | end | ||
− | if o.month and args.Tag then | + | if o and o.month and args.Tag then |
s = args.Tag:match( "^0?([123]?%d)%.?$" ) | s = args.Tag:match( "^0?([123]?%d)%.?$" ) | ||
if s then | if s then | ||
Zeile 308: | Zeile 308: | ||
r = false | r = false | ||
end | end | ||
− | if r then | + | if r and o then |
r = o | r = o | ||
args.Datum = o | args.Datum = o |
Version vom 19. Mai 2016, 00:33 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-19"
--[=[
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,
ISSNformalFalsch = 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,
KBytes = 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" },
ISSNformalFalsch = { "id", "ISSNfalsch" },
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" },
KBytes = { "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 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
fehler( "Wert", "'Monat'=" .. args.Monat )
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( "Wert", "'Monat'=" .. args.Monat )
r = false
elseif s ~= args.Monat then
fehler( "Format", "'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
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 and o 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