Modul:Vorlage:Literatur

Aus Handbuch.io

local Serial = "2016-07-02" --[=[ Unterstützung für Vorlage:Literatur ]=]


-- Global local Zitation local Schrei local Selbst = "Vorlage:Literatur" local KategorieBeginn = "Wikipedia:Vorlagenfehler" local Kategorien =

       { Intern              = { s = "/Interner Fehler" },
         Parameter           = { s = "/Parameterfehler" },
         ISBNistFormalFalsch = { s = "/Parameter ISBNistFormalFalsch" },
         Monat               = { s = "/Parameter Monat" },
         MonatTag            = { s = "/Parameter Monat, Tag" },
         Temp1               = { s = "/Temp1" },
         Temp2               = { s = "/Temp2" },
         Temp3               = { s = "/Temp3" },
         Temp4               = { s = "/Temp4" },
         TitelP              = { s = "/Parameter Titel-P" }
       }

local ParValid = {

   Autor               = { Autorin=true,
                           Autoren=true,
                           Autorinnen=true },
   Hrsg                = { Herausgeber = { low=true },
                           Herausgeberin=true },
   Titel               = { ["Titel-P"] = { low=true } },

-- ["Titel-P"] = 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    = true,
   ISBNdefekt          = true,
   ISBNistFormalFalsch = false,
   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 },
                           arxiv = { low=true } },
   bibcode             = true,
   DOI                 = true,
   DNB                 = true,
   JSTOR               = true,
   LCCN                = true,
   Lizenznummer        = 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" },
   Hrsg             = { "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" },
   ISBNdefekt       = { "id",       "ISBNdefekt" },
   ISSN             = { "id",       "ISSN" },
   ISSNformalFalsch = { "id",       "ISSNfalsch" },
   Umfang           = { "print",    "Umfang" },
   Sprache          = { "bas",      "Sprache" },
   Kommentar        = { "bas",      "Kommentar" },
   Zitat            = { "bas",      "Zitat" },
   Originaltitel    = { "orig",     "Titel" },
   Originalsprache  = { "orig",     "Sprache" },
   Originalort      = { "orig",     "Ort" },
   Originaljahr     = { "orig",     "Jahr" },
   ["Ü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" },
   Lizenznummer     = { "id",       "Lizenznummer" },
   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, oder doch?


local function falsch( a )

   -- Zeige Fehler mit class=error unbedingt
   -- Parameter:
   --     a  -- string mit Text
   if Schrei then
       Schrei = string.format( "%s
%s", Schrei, a ) else Schrei = a end

end -- falsch()


local function falschparker( arglist )

   -- Ausgabe der unbedingten Fehler mit class=error
   -- Parameter:
   --     arglist  -- table mit Vorlagenparametern
   local r
   if Schrei then
       local max = 100000000
       local id  = math.floor( os.clock() * max )
       local e, s
       if id % 10000 == 0 then
           for k, v in pairs( arglist ) do
               s = type( k )
               if s == "number" then
                   id = id + k
                   s  = ""
               else
                   s = k
               end
               s = s .. v
               for i = 1, #s do
                   id = id + s:byte( i, i )
                   if id > max then
                       id = id - max
                   end
               end -- for i
           end -- for k, v
       end
       s = string.format( "error_%d", id )
       e = mw.html.create( "span" )
                  :addClass( "error" )
                  :attr( "id", s )
                  :wikitext( Schrei )
       r = tostring( e )
       Schrei = string.format( "Fehler in %s
%s", s, Selbst, Schrei ) e = mw.html.create( "div" )  :addClass( "error" )  :wikitext( Schrei ) mw.addWarning( tostring( e ) ) else r = "" end return r

end -- falschparker()


local function fault( a )

   -- Formatiere Fehler mit class=error einstellungsabhängig
   -- Parameter:
   --     a  -- string mit Text
   local r
   if type( Zitation ) == "table" then
       r = Zitation.fault( a )
   else
       r = falsch( 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" },
                  MonatTag            = { k = "MonatTag" },
                  Monat               = { k = "Monat" },--OBSOLET
                  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
               r = string.format( "%s%s*** %s: %s",
                                  r,  sep,  v.s or "",  v.e )
               sep = " "
           end
       end -- for k, v
       r = "
" .. 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", r, KategorieBeginn, s, v.s ) end end -- for k, v return r

end -- fehlerliste()




local Titel = function ( args )

   --    OBSOLET   nach Bereinigung im ANR; Kat zeitweise ausgesetzt
   if args[ "Titel-P" ]        and false then
       fehler( "TitelP" )
   end

end -- Titel()


FunLit.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( "Wert", "'Monat'=" .. args.Monat )
                       r = false
                   elseif s ~= args.Monat  and
                          "0" .. 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( "MonatTag",  "'Tag'=" .. args.Tag )
                       r = false
                   elseif s ~= args.Tag  and
                          "0" .. s ~= args.Tag then
                       fehler( "Format",  "'Tag'=" .. args.Tag )
                   end
               end
           elseif args.Tag then
               shit = "'Tag' ohne 'Monat'"
               r = false
           elseif args.Datum == r then
               fehler( "Temp4" )
           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 )
           args.Jahr = false
           fehler( "Temp2" )
       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" )
      falsch( shit )
   end
   return r

end -- FunLit.Datum()


local Band = function ( args )

   --    OBSOLET   nach Bereinigung im ANR
   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 )

   --    OBSOLET   nach Bereinigung im ANR
   if args.Reihe  and
      not args.NummerReihe  and
      not args.Sammelwerk then
       args.NummerReihe = args.Nummer
       args.Nummer      = nil
   end

end -- Nummer()


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 ISBN = function ( args )

   --    OBSOLET   nach Bereinigung im ANR
   if args.ISBNistFormalFalsch then
       local scream = "*** 'ISBNistFormalFalsch' unwirksam; siehe" ..
                      " Doku"
       falsch( scream )
       fehler( "ISBNistFormalFalsch" )
   end

end -- ISBN()


local Typ = function ( args )

   --    OBSOLET   nach Bereinigung im ANR; Kat zeitweise ausgesetzt
   if args.Typ  and  args.Typ ~= "wl" then
       local s = args.Typ:upper()
       if s == "PDF" then
           args.Format = "PDF"
           args.Typ    = false
           fehler( "Temp3" )
       elseif s == "HTML" then
           args.Typ = false
           fehler( "Temp3" )
       else
           --  fehler( "Temp###############" )
       end
   end

end -- Typ()


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 )
   Sprache( pars )
   ISBN( pars )     -- OBSOLET
   Typ( 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() .. falschparker( arglist )

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