Modul:Citation
Die Dokumentation für dieses Modul kann unter Modul:Citation/doc erstellt werden
-- documentation
local citation = {
suite = 'Citation',
serial = '2020-03-26',
}
-- module import
local cu = require( 'Module:Citation/utilities' )
local cc = require( 'Module:Citation/COinS' )
local cx = require( 'Module:Check isxn' )
local li = require( 'Module:LinkISBN' )
local uc = require( 'Module:UrlCheck' )
local yn = require( 'Module:Yesno' )
-- module variable
local ct = {}
-- global variables
-- list of possible type values
local refTypes = {
book = { 'book', 'Buch' },
map = { 'map', 'Karte' },
collection = { 'collection', 'Sammelwerk' },
journal = { 'journal', 'Zeitschrift' },
newspaper = { 'newspaper', 'Zeitung' },
web = { 'web', 'Web', 'Internet' }
}
-- list of possible status values
local urlStates = {
dead = { 'dead', 'offline' },
live = { 'live', 'online' },
usurped = { 'unfit', 'usurped', 'usurpiert' }
}
-- list of possible parameter
-- no index: possible parameter names
-- types: reference types for which parameter is valid
-- COinS: COinS key
-- COinS_id: COinS id
-- cleanup = true: complete cleanup
local params = {
type = { 'type', 'Typ', cleanup = true },
author = { 'Autor', COinS = 'rft.au', cleanup = true },
editor = { 'Herausgeber', 'Hrsg', cleanup = true },
title = { 'Titel', COinS = 'rft.title', cleanup = true },
chapter = { 'Kapitel', types = 'book', COinS = 'rft.atitle', cleanup = true },
collection = { 'Sammelwerk', types = 'collection', cleanup = true },
journal = { 'Zeitschrift', 'Sammelwerk', types = 'journal', COinS = 'rft.jtitle', cleanup = true },
newspaper = { 'Zeitung', 'Sammelwerk', types = 'newspaper', COinS = 'rft.jtitle', cleanup = true },
website = { 'Website', 'Internet', 'Sammelwerk', types = 'web', cleanup = true },
abbr = { 'Abk', types = { 'collection', 'journal', 'newspaper' }, cleanup = true },
url = { 'Online', 'URL', types = { 'book', 'map', 'collection', 'journal', 'newspaper', 'web' }, cleanup = true },
articleUrl = { 'Onlineaufsatz', 'Aufsatz-URL', types = { 'journal' }, cleanup = true },
siteUrl = { 'Site-URL', 'Website-URL', types = { 'collection', 'newspaper', 'web' }, cleanup = true },
jstor = { 'JSTOR', types = { 'journal', 'newspaper' }, cleanup = true },
KBytes = { 'KBytes', 'kBytes', 'kbytes', cleanup = true },
MBytes = { 'MBytes', 'Mbytes', cleanup = true },
accessDate = { 'Zugriff', 'Abruf', cleanup = true },
scale = { 'Maßstab', types = 'map', cleanup = true },
place = { 'Ort', COinS = 'rft.place', cleanup = true },
publisher = { 'Verlag', 'Verleger', types = { 'book', 'map', 'collection', 'web' }, COinS = 'rft.pub', cleanup = true },
date = { 'Datum', 'Jahr', COinS = 'rft.date', cleanup = true },
edition = { 'Auflage', types = { 'book', 'map', 'collection' }, COinS = 'rft.edition', cleanup = true },
volume = { 'Band', COinS = 'rft.volume', cleanup = true },
issue = { 'Ausgabe', 'Nummer', 'Heft', types = { 'journal', 'newspaper' }, COinS = 'rft.issue', cleanup = true },
pages = { 'Seite', 'Seiten', types = { 'book', 'collection', 'journal', 'newspaper' }, COinS = 'rft.pages', cleanup = true },
columns = { 'Spalten', types = { 'book', 'collection', 'journal', 'newspaper' }, cleanup = true },
extent = { 'Umfang', 'Seitenanzahl', types = { 'book', 'collection', 'map' } },
series = { 'Serie', 'Reihe', types = { 'book', 'collection', 'map' }, COinS = 'rft.series', cleanup = true },
series2 = { 'Serie2', 'Reihe2', types = { 'book', 'collection', 'map' }, cleanup = true },
series3 = { 'Serie3', 'Reihe3', types = { 'book', 'collection', 'map' }, cleanup = true },
isbn = { 'ISBN', types = { 'book', 'collection', 'map', 'journal' }, COinS = 'rft.isbn', cleanup = true },
dnb = { 'DNB', types = { 'book', 'collection', 'map' }, cleanup = true },
oclc = { 'OCLC', types = { 'book', 'collection', 'map' }, COinS_id = 'info:oclcnum', cleanup = true },
issn = { 'ISSN', COinS = 'rft.issn', cleanup = true },
eissn = { 'EISSN', cleanup = true },
doi = { 'DOI', COinS_id = 'info:doi', cleanup = true },
language = { 'Sprache' },
comment = { 'Kommentar', 'Zitat' },
ignoreError = { 'ignoreError', 'ignoreErrors', 'keinFehler', 'kein Fehler', cleanup = true },
urlStatus = { 'URL-Status', cleanup = true },
archiveUrl = { 'Archiv-URL', cleanup = true },
archiveDate = { 'Archiv-Datum', 'Archivdatum', cleanup = true },
format = { 'Format', cleanup = true }
}
-- list of formatter strings
local formatters = {
-- author
auAuthor = '%s: ',
auAuthorEditor = '%s ; %s',
auEditor = '%s (Hrsg.)',
-- title
tiAll = "%s. ",
tiChapter = "Kapitel ''%s''",
tiIn = 'In: ',
tiScale = 'Maßstab: %s. ',
tiSeries = '(%s)',
tiTitle = "''%s''",
tiVolume = "''%s''; Bd. %s",
-- publisher
puAll = '%s.',
puDateEdition = '%s (%d. Auflage)',
puPlaceDate = '%s, %s',
puPlacePub = '%s: %s',
-- additions
addColumns = 'Sp. %s',
addComment = ' %s',
addDelimiter1 = ', ',
addDelimiter2 = '; ',
addExtent = '%s Seiten',
addLanguage = ' (%s)',
addPages = 'S. %s',
-- periodical
prAbbr = ' (%s)',
prIssue = 'Nr. %s',
prPlace = ' <%s>',
prVolume = 'Bd. %s',
prVolIssue = '%s,%s',
prVolYear = '%s (%s)',
-- newspaper
nsVolume = 'Jg. %s',
-- database ids
dbDnb = '[[w:Deutsche Nationalbibliothek|DNB]] [http://d-nb.info/%s %s]',
dbDoi = '[[w:Digital Object Identifier|doi]]:%s',
dbOclc = '[[w:Online Computer Library Center|OCLC]] [https://worldcat.org/oclc/%s %s]',
dbIssn = '[[w:Internationale Standardnummer für fortlaufende Sammelwerke|ISSN]] [http://zdb-katalog.de/list.xhtml?t=iss%3D%22xx1xx%22&key=cql xx1xx]',
dbJstor = '[[w:JSTOR|JSTOR]] [https://www.jstor.org/stable/%s %s]',
-- web
wbAccess = 'abgerufen am %s',
wbKBytes = 'Dateigröße: %s KByte',
wbMBytes = 'Dateigröße: %s MByte',
-- archive
arArchived = 'Archiviert',
arOriginal = 'Original',
arArchive = ' %s vom %s.',
arArchiveDate = ' %s vom %s am %s.'
}
-- error categories and hints
local texts = {
decimalPoint = ',',
noTitel = '<span class="error">Fehlender Titel</span>',
noTitelUrl = '<span class="error">Titel und URL fehlen</span>[[Category:Literatur: Titel und URL fehlen]]',
noURL = '<span class="error">Ungültige URL</span>[[Category:Literatur: ungültige URL]]',
unknownParam = '<span class="error">Ungültiger Parameter: %s</span>[[Category:Literatur: ungültige Parameter]]',
unknownParams = '<span class="error">Ungültige Parameter: %s</span>[[Category:Literatur: ungültige Parameter]]',
unknownTitle = '[[Category:Literatur: fehlender Titel]]',
unknownPeriodical = '[[Category:Literatur: fehlender Titel eines Periodikums]]',
wrongDate = '<span class="error">Ungültiges Datum</span>[[Category:Literatur: ungültiges Datum]]',
wrongIssn = '<span class="error">Ungültige ISSN</span>[[Category:Seiten mit ISSN-Fehlern]]',
wrongPages = '<span class="error">Ungültige Seiten</span>[[Category:Literatur: ungültige Seiten]]',
wrongType = '<span class="error">Ungültiger Typ</span>[[Category:Literatur: ungültiger Typ]]',
wrongValue = '<span class="error">Ungültiger Wert: %s</span>[[Category:Literatur: ungültiger Wert]]',
wrongValues = '<span class="error">Ungültige Werte: %s</span>[[Category:Literatur: ungültiger Wert]]',
KBytesMBytes = '<span class="error">KBytes und MBytes gleichzeitig</span>[[Category:Literatur: KBytes und MBytes gleichzeitig]]'
}
-- detcted date format y, y-m, y-m-d
local dateFormat = ''
-- check for possible arguments against params table
local function checkParams( frameArgs )
local args = {}, key, key2, ok, value, value2
local complete = {}
local wrongParams = {}
local aType = frameArgs.type
for key, value in pairs( params ) do
if not value.types or cu.inArray( value.types, aType ) then
for key2, value2 in ipairs( value ) do
complete[ value2 ] = key
args[ key ] = args[ key ] or
cu.cleanupParameters( frameArgs[ value2 ], value.cleanup )
end
args[ key ] = args[ key ] or ''
end
end
-- no missing items
for key, value in pairs( params ) do
if not args[ key ] then
args[ key ] = ''
end
end
for key, value in pairs( frameArgs ) do
if not complete[ key ] then
table.insert( wrongParams, key )
end
end
if #wrongParams == 1 then
cu.addErrorMsg( mw.ustring.format( texts.unknownParam, table.concat( wrongParams, ', ' ) ) )
elseif #wrongParams > 0 then
cu.addErrorMsg( mw.ustring.format( texts.unknownParams, table.concat( wrongParams, ', ' ) ) )
end
return args
end
-- check parameter values
local function checkValues( args )
local i, key, value
local wrong = {}
local aType = args.type
if aType == 'web' and not cu.isSet( args.title ) and not cu.isSet( args.url ) then
title = texts.noTitle
cu.addErrorMsg( texts.noTitleUrl )
elseif not cu.isSet( args.title ) then
title = texts.noTitle
cu.addErrorMsg( texts.unknownTitle )
end
args.pages = cu.cleanupPageNumbers( args.pages )
args.columns = cu.cleanupPageNumbers( args.columns )
if cu.isSet( args.KBytes ) and cu.isSet( args.MBytes ) then
args.MBytes = ''
cu.addErrorMsg( texts.KBytesMBytes )
end
args.ignoreError = yn( args.ignoreError, false )
if args.ignoreError then
args.ignoreError = 'true'
else
args.ignoreError = 'false'
end
if cu.isSet( args.date ) then
if args.date:match( '^[12]%d%d%d%-[01]?%d%-[0123]?%d$' ) then
dateFormat = 'j. F Y'
elseif args.date:match( '^[12]%d%d%d%-[01]?%d$' ) then
dateFormat = 'M Y'
elseif args.date:match( '^[12]%d%d%d$' ) then
dateFormat = 'Y'
else
args.date = args.date:match( '%d+' ) or ''
if cu.isSet( args.date ) then
i = tonumber( args.date )
if i >= 1000 and i < 2100 then
dateFormat = 'Y'
else
args.date = ''
cu.addErrorMsg( texts.wrongDate )
end
end
end
end
for key, value in ipairs( { 'accessDate', 'archiveDate' } ) do
if cu.isSet( args[ value ] ) and
not args[ value ]:match( '^20%d%d%-[01]?%d%-[0123]?%d$' ) then
args[ value ] = ''
cu.addErrorMsg( texts.wrongDate )
end
end
for key, value in ipairs( { 'url', 'articleUrl', 'archiveUrl' } ) do
if cu.isSet( args[ value ] ) and uc.isUrl( args[ value ] ) > 2 then
args[ value ] = ''
cu.addErrorMsg( texts.noURL )
end
end
-- copying for historical reasons
if aType == 'journal' then
args.siteUrl = args.url
end
if aType == 'journal' then
args.url = args.articleUrl
end
args.urlStatus = cu.getKey( args.urlStatus, urlStates )
if not cu.isSet( args.urlStatus ) and cu.isSet( args.archiveUrl ) then
args.urlStatus = 'dead'
elseif not cu.isSet( args.urlStatus ) then
args.urlStatus = 'live'
end
if args.urlStatus == 'dead' then
args.originalUrl = args.url
args.url = args.archiveUrl
args.archiveUrl = ''
elseif args.urlStatus == 'usurped' then
args.url = args.archiveUrl
args.archiveUrl = ''
end
for key, value in ipairs( { 'dnb', 'oclc', 'jstor', 'KBytes' } ) do
if cu.isSet( args[ value ] ) and not args[ value ]:match( '^%d+$' ) then
args[ value ] = ''
table.insert( wrong, value )
end
end
if cu.isSet( args.doi ) and not mw.ustring.match( args.doi, '^10%.%d+/.+$' ) then
args.doi = ''
table.insert( wrong, 'doi' )
end
if cu.isSet( args.edition ) then
args.edition = args.edition:match( '%d+' ) or ''
if args.edition == '1' then
args.edition = ''
end
end
if cu.isSet( args.type ) and args.type ~= 'map' then
args.scale = ''
end
if #wrong == 1 then
cu.addErrorMsg( mw.ustring.format( texts.wrongValue, wrong[ 1 ] ) )
elseif #wrong > 1 then
cu.addErrorMsg( mw.ustring.format( texts.wrongValues, table.concat( wrong, ', ' ) ) )
end
end
-- make author part
local function makeAuthor( author, editor )
if cu.isSet( editor ) then
editor = mw.ustring.format( formatters.auEditor, editor )
end
if cu.isSet( author ) and cu.isSet( editor ) then
author = mw.ustring.format( formatters.auAuthorEditor, author, editor )
elseif not cu.isSet( author ) and cu.isSet( editor ) then
author = editor
end
if cu.isSet( author ) then
return mw.ustring.format( formatters.auAuthor, author )
else
return ''
end
end
local function makeTitle( title, volume, url, scale )
if not cu.isSet( title ) then
title = texts.noTitle
cu.addErrorMsg( texts.unknownTitle )
end
if cu.isSet( url ) then
title = title:gsub( '[%[%]]', '' )
title = '[' .. url .. ' ' .. title .. ']'
end
if cu.isSet( volume ) then
title = mw.ustring.format( formatters.tiVolume, title, volume )
else
title = mw.ustring.format( formatters.tiTitle, title )
end
title = mw.ustring.format( formatters.tiAll, title )
if cu.isSet( scale ) then
title = title .. mw.ustring.format( formatters.tiScale, scale )
end
return title
end
local function makeIssnLink( issn, ignoreError )
local text = ''
if ignoreError ~= 'true' then
text = texts.wrongIssn
end
return formatters.dbIssn:gsub( 'xx1xx', issn )
.. cx.check_issn( { args = { [ 1 ] = issn, error = text } } )
end
local function makePublisher( args, tab )
local theDate = ''
if cu.isSet( args.date ) then
if cu.isSet( dateFormat ) and dateFormat ~= 'Y' then
dateFormat = 'M Y'
end
theDate = cu.getDate( args.date, dateFormat, texts.wrongDate )
end
local published = ''
if cu.isSet( theDate ) and cu.isSet( args.edition ) then
theDate = mw.ustring.format( formatters.puDateEdition, theDate, args.edition )
end
if cu.isSet( args.place ) and cu.isSet( args.publisher ) then
published = mw.ustring.format( formatters.puPlacePub, args.place, args.publisher )
elseif cu.isSet( args.place ) then
published = args.place
elseif cu.isSet( args.publisher ) then
published = args.publisher
end
if not cu.isSet( published ) then
published = theDate
elseif cu.isSet( theDate ) then
published = mw.ustring.format( formatters.puPlaceDate, published, theDate )
end
if cu.isSet( published ) then
table.insert( tab, published )
end
end
local function makeSeries( args, tab )
local key, value
for key, value in ipairs( { 'series', 'series2', 'series3' } ) do
if cu.isSet( args[ value ] ) then
table.insert( tab, mw.ustring.format( formatters.tiSeries, args[ value ] ) )
end
end
end
local function makeIsbn( args, tab )
if cu.isSet( args.isbn ) then
table.insert( tab,
li._linkISBNSet( { isbn = args.isbn, ignoreError = args.ignoreError } ) )
elseif cu.isSet( args.dnb ) then
table.insert( tab, mw.ustring.format( formatters.dbDnb, args.dnb, args.dnb ) )
elseif cu.isSet( args.oclc ) then
table.insert( tab, mw.ustring.format( formatters.dbOclc, args.oclc, args.oclc ) )
end
if cu.isSet( args.issn ) then
table.insert( tab, makeIssnLink( args.issn, args.ignoreError ) )
end
if cu.isSet( args.eissn ) then
table.insert( tab, makeIssnLink( args.eissn, args.ignoreError ) )
end
end
local function makePages( args, tab )
if cu.isSet( args.pages ) then
table.insert( tab,
mw.ustring.format( formatters.addPages, args.pages:gsub( '-', '–' ) ) )
end
if cu.isSet( args.columns ) then
table.insert( tab,
mw.ustring.format( formatters.addColumns, args.columns:gsub( '-', '–' ) ) )
end
end
local function makeDoi( args, tab )
if cu.isSet( args.extent ) then
if args.extent:match( '^%d+$' ) then
args.extent = mw.ustring.format( formatters.addExtent, args.extent )
end
table.insert( tab, args.extent )
end
if cu.isSet( args.doi ) then
table.insert( tab,
mw.ustring.format( formatters.dbDoi, cu.makeDoiLink( args.doi ) ) )
end
if cu.isSet( args.jstor ) then
table.insert( tab,
mw.ustring.format( formatters.dbJstor, args.jstor, args.jstor ) )
end
end
local function makeWebInfo( args, tab )
local kb
if cu.isSet( args.url ) or cu.isSet( args.articleUrl ) or cu.isSet( args.archiveUrl ) then
if cu.isSet( args.accessDate ) then
args.accessDate = cu.getDate( args.accessDate, 'j. F Y', texts.wrongDate )
if cu.isSet( args.accessDate ) then
table.insert( tab,
mw.ustring.format( formatters.wbAccess, args.accessDate ) )
end
end
if cu.isSet( args.KBytes ) then
kb = tonumber( args.KBytes ) or 0
if kb >= 1024 then
table.insert( tab,
mw.ustring.format( formatters.wbMBytes,
tostring( cu.round( kb / 1024, 3 ) ):gsub( '%.', texts.decimalPoint ) ) )
else
table.insert( tab,
mw.ustring.format( formatters.wbKBytes, args.KBytes ) )
end
elseif cu.isSet( args.MBytes ) then
table.insert( tab,
mw.ustring.format( formatters.wbMBytes, args.MBytes ) )
end
end
end
local function makeArchived( args )
local archived = formatters.arArchived
local original = formatters.arOriginal
if cu.isSet( args.archiveUrl ) then
archived = '[' .. args.archiveUrl .. ' ' .. archived .. ']'
end
if cu.isSet( args.originalUrl ) then
original = '[' .. args.originalUrl .. ' ' .. original .. ']'
end
local day = '', result
if cu.isSet( args.archiveDate ) then
day = cu.getDate( args.date, 'l, j. F Y', texts.wrongDate )
end
if day ~= '' then
result = mw.ustring.format( formatters.arArchiveDate, archived, original, day )
else
if cu.isSet( args.archiveDate ) then
cu.addErrorMsg( texts.wrongDate )
end
result = mw.ustring.format( formatters.arArchive, archived, original )
end
return result
end
local function makeLanguageComment( args, result )
if cu.isSet( args.language ) then
result = result .. mw.ustring.format( formatters.addLanguage, args.language )
end
if result ~= '' then
result = mw.ustring.format( formatters.puAll, result )
end
if cu.isSet( args.archiveUrl ) or cu.isSet( args.originalUrl )
or args.urlStatus == 'usurped' then
result = result .. makeArchived( args )
end
if cu.isSet( args.comment ) then
result = result .. mw.ustring.format( formatters.addComment, args.comment )
end
return result
end
local function makePublished( args )
result = {}
makePublisher( args, result )
makeSeries( args, result )
makeIsbn( args, result )
if cu.isSet( args.chapter ) then
table.insert( result, mw.ustring.format( formatters.tiChapter, args.chapter ) )
end
makePages( args, result )
if #result > 0 then
result = { table.concat( result, formatters.addDelimiter1 ) }
end
makeDoi( args, result )
makeWebInfo( args, result )
result = table.concat( result, formatters.addDelimiter2 )
return makeLanguageComment( args, result )
end
local function makeBook( args )
local author, title
if args.type == 'map' or args.type == 'book' then
author = makeAuthor( args.author, args.editor )
title = makeTitle( args.title, args.volume, args.url, args.scale )
else
author = makeAuthor( '', args.editor )
title = makeTitle( args.collection, args.volume, args.url, args.scale )
end
return author .. title .. makePublished( args )
end
local function makeCollection( args )
local author, collection, editor, title
author = makeAuthor( args.author, '' )
title = makeTitle( args.title, args.volume, args.url, '' )
editor = makeAuthor( '', args.editor )
collection = makeTitle( args.collection, args.volume, args.siteUrl, '' )
return author .. title .. formatters.tiIn .. editor .. collection
.. makePublished( args )
end
local function makeJournalTitle( args )
local title
if args.type == 'journal' then
title = args.journal
else
title = args.newspaper
end
if title == '' then
title = texts.noTitel
cu.addErrorMsg( texts.unknownPeriodical )
else
title = mw.ustring.format( formatters.tiTitle, title )
end
if cu.isSet( args.siteUrl ) then
title = title:gsub( '[%[%]]', '' )
title = '[' .. args.siteUrl .. ' ' .. title .. ']'
end
if cu.isSet( args.place ) then
title = title .. mw.ustring.format( formatters.prPlace, args.place )
end
if cu.isSet( args.abbr ) then
title = title .. mw.ustring.format( formatters.prAbbr, args.abbr )
end
return title
end
local function makeJournalInfo( args, tab )
local year = ''
if cu.isSet( args.date ) then
year = cu.getDate( args.date, dateFormat, texts.wrongDate )
end
local volume = ''
if cu.isSet( args.volume ) then
volume = mw.ustring.format( formatters.prVolume, args.volume )
if cu.isSet( args.issue ) then
volume = mw.ustring.format( formatters.prVolIssue, volume, args.issue )
end
if year ~= '' then
volume = mw.ustring.format( formatters.prVolYear, volume, year )
end
else
if cu.isSet( args.issue ) then
volume = mw.ustring.format( formatters.prIssue, args.issue )
if year ~= '' then
volume = mw.ustring.format( formatters.prVolYear, volume, year )
end
else
volume = year
end
end
if volume ~= '' then
table.insert( tab, volume )
end
end
local function makeNewspaperInfo( args, tab )
if cu.isSet( args.volume ) then
table.insert( tab,
mw.ustring.format( formatters.nsVolume, args.volume ) )
end
if cu.isSet( args.issue ) then
table.insert( tab,
mw.ustring.format( formatters.prIssue, args.issue ) )
end
local day = ''
if cu.isSet( args.date ) then
if dateFormat == 'j. F Y' then
-- following result can be ''
day = cu.getDate( args.date, 'l, j. F Y', texts.wrongDate )
else
cu.addErrorMsg( texts.wrongDate )
end
end
if day ~= '' then
table.insert( tab, day )
end
end
local function makePeriodical( args )
local result = { makeAuthor( args.author, '' )
.. makeTitle( args.title, '', args.url, '' ) .. formatters.tiIn
.. makeJournalTitle( args ) }
makeIsbn( args, result )
if args.type == 'journal' then
makeJournalInfo( args, result )
else --newspaper and web
makeNewspaperInfo( args, result )
end
makePages( args, result )
makeDoi( args, result )
makeWebInfo( args, result )
result = table.concat( result, formatters.addDelimiter1 )
return makeLanguageComment( args, result )
end
-- remove adjoining punctuation marks
local function finalCleanup( s )
s = mw.ustring.gsub( s, '%.+%.', '.' )
s = mw.ustring.gsub( s, '([!%?])(%s%.+)', '%1' )
return mw.ustring.gsub( s, '([,;:])(%s%.+)', '.' )
end
local function makeCitation( frameArgs )
local args, citation
args = checkParams( frameArgs )
checkValues( args )
if args.type == 'map' or args.type == 'book' then
citation = makeBook( args )
elseif args.type == 'collection' then
citation = makeCollection( args )
elseif args.type == 'journal' or args.type == 'newspaper'
or args.type == 'web' then
citation = makePeriodical( args )
else
args.type = 'book'
citation = texts.wrongType .. makeBook( args )
end
citation = finalCleanup( citation )
cc.prepareForCOinS( args )
return cu.getErrorMsgs()
.. '<cite style="font-style: normal;" class="citation ' .. args.type
.. ' printNoLink">' .. citation .. '</cite>'
.. cc.makeCOinS( args, params )
end
function ct.citation( frame )
local fType = frame.args.type
local args = frame:getParent().args
if cu.isSet( fType ) then
args.type = fType
else
args.type = cu.getKey( cu.getArgValue( params, 'type', args ), refTypes )
end
if not cu.isSet( args.type ) then
if cu.getArgValue( params, 'scale', args ) ~= '' then
args.type = 'map'
elseif cu.getArgValue( params, 'collection', args ) ~= '' then
args.type = 'collection'
elseif cu.getArgValue( params, 'journal', args ) ~= '' then
args.type = 'journal'
elseif cu.getArgValue( params, 'newspaper', args ) ~= '' then
args.type = 'newspaper'
elseif cu.getArgValue( params, 'website', args ) ~= '' then
args.type = 'web'
else
args.type = 'book'
end
end
return makeCitation( args )
end
return ct