Modulo:Box interwiki

Da Wikinotizie, le notizie a contenuto aperto
Jump to navigation Jump to search

Questo modulo implementa le funzionalità di alcuni dei template per i box con collegamenti interwiki contenuti nella Categoria:Template Wikimedia.

L'unica funzione esportata è getBox. Nel resto del testo, ogni volta che ci si riferisce ad un #invoke al modulo, è sottintesa la chiamata di questa funzione.

Il modulo:Box interwiki/Man generico per template derivati fornisce dei manuali standardizzati per i template derivati.

Gestione dei parametri[modifica]

Parametri di #invoke[modifica]

Per i box che linkano una sola pagina, il modulo ha bisogno solo di questi parametri. I box che linkano più pagine, invece, richiedono anche i parametri posizionali nella chiamata al template derivato; vedi alla sezione Parametri dei template derivati.

  parametro o/f [t 1]   [t 2]   default [t 3]   descrizione
pagina o pagina da linkare con un wikilink

[[prefisso:pagina|etichetta-pagina]]

progetto o nome del progetto per il wikilink alla Pagina principale del progetto

p.e. Wikipedia

prefisso o prefisso per i wikilink al progetto

p.e. per Wikipedia è w

vedi pagina

immagine o file del logo del progetto
etichetta-pagina f x pagina testo da visualizzare nel wikilink alla pagina

vedi pagina

lingua f it codice linguistico del progetto
progetto-multilingue f da valorizzare con un testo qualsiasi quando si tratta di un progetto multilingue

p.e. Commons o Meta-Wiki

influenza l'uso che il modulo fa dei parametri dei template derivati

dimensione-immagine f x55px dimensione da impostare se con il valore di default le dimensioni del logo del progetto risultano sbilanciate rispetto a quelle degli altri progetti
una-pagina f una pagina testo che sostituisce "una pagina" in pre-pagina

p.e. "una voce" per Wikipedia

pre-progetto f testo da inserire prima del wikilink al progetto
pre-pagina f ha una pagina su sostituzione completa del testo tra il wikilink al progetto e quello alla pagina, nel caso di box con una sola pagina linkata
pre-pagina-multi f ha le pagine: sostituzione completa del testo tra il wikilink al progetto e quello alla prima pagina, nel caso di box con più pagine linkate
multi-pagina-come f x pagine modalita di lettura dei parametri posizionali da {{{ 1 + parametri-riservati }}} in su

i valori ammessi sono :

  • pagine
ognuno è una pagina da linkare
  • pagina-etichetta
per coppie  [[ pagina | etichetta ]]
  • lingua-pagina
per coppie  [[ lingua : pagina ]]
  • lingua-pagina-etichetta
per triplette  [[ lingua : pagina | etichetta ]]

lingua-pagina e lingua-pagina-etichetta sono incompatibili con progetto-multilingue e ricadono, rispettivamente, su pagine e pagina-etichetta

parametri-riservati f 2 numero di parametri posizionali riservati al template derivato

il modulo ricava gli eventuali link aggiuntivi a partire dal primo successivo

Note
  1. obbligatorio / facoltativo
  2. Per i parametri segnati con una x, il valore impostato in #invoke può essere sovrascritto impostando lo stesso parametro nella chiamata al template derivato.
  3. Il tratto — indica l'assenza di un valore di default.

Esempi[modifica]

Il testo tra grafe indica i parametri valorizzati.

Base[modifica]

Per mostrare esattamente il risultato dei parametri, i wikilink sono mostrati come wikicode, grazie al fatto che la presenza delle grafe ne fa fallire il rendering.

In un template utilizzabile almeno il parametro pagina è valorizzato tramite uno dei parametri del template stesso.

{{#invoke: Box interwiki | getBox
| pagina   = {pagina}
| progetto = {progetto}
| prefisso = {prefisso}
| immagine = Arma ignota.jpg
}}
logo {progetto}

[[{prefisso}:Pagina principale|{progetto}]] ha una pagina su [[{prefisso}:{pagina}|{pagina}]].

[[Categoria:Pagine con box interwiki verso {progetto}|Modulo:Box interwiki]]

Messaggio d'errore in caso di parametri obbligatori mancanti[modifica]

Errore nell'#invoke al Modulo:Box interwiki.

I seguenti parametri devono essere sempre valorizzati :

  • pagina
  • progetto
  • prefisso
  • immagine


Base + lingua[modifica]

Per mostrare esattamente il risultato dei parametri, i wikilink sono mostrati come wikicode, grazie al fatto che la presenza delle grafe ne fa fallire il rendering.

Quando è indicato un codice lingua corretto, "lingua" in "in lingua ha una pagina su" viene sostituito dal nome della lingua per esteso.

logo {progetto}

[[{prefisso}:{lingua}:Main Page|{progetto}]] in ha una pagina su [[{prefisso}:{lingua}:{pagina}|{pagina}]].

[[Categoria:Pagine con box interwiki verso {progetto}|Modulo:Box interwiki]]

una-pagina + etichetta-pagina[modifica]
logo Progetto

Progetto ha {una-pagina} su {etichetta-pagina}.

pre-progetto + pre-pagina[modifica]
logo Progetto

{pre-progetto} Progetto {pre-pagina} pagina.

Parametri dei template derivati[modifica]

parametri-riservati

I template derivati dal modulo (ovvero che contengono un #invoke allo stesso) possono adoperare qualsiasi parametro con nome, per valorizzare i parametri di #invoke o per qualsiasi altro uso interno al template.

Una particolare gestione avviene invece per i parametri posizionali.

I primi parametri posizionali (nel numero indicato da parametri-riservati) sono a libera disposizione del template. In diversi template {{{ 1 }}} valorizza pagina e {{{ 2 }}} valorizza lingua.

I parametri posizionali da {{{ 1 + parametri-riservati }}} in su, se presenti, sono gestiti dal modulo e, una loro eventuale gestione anche nel template deve essere compatibile con quella effettuata dal modulo. In particolare, la valorizzazione del parametro {{{ 1 + parametri-riservati }}} chiede al modulo la creazione di un box con link a più pagine.

L'interpretazione dei parametri posizionali dipende dal valore di multi-pagina-come. Vedi nella tabella alla sezione Parametri di #invoke.

Una stringa vuota in una posizione corrispondente a una etichetta indica di non usare un testo sostitutivo per il link, ma il nome della pagina indicato dal parametro precedente.

Una stringa vuota in una posizione corrispondente a una lingua indica di usare la stessa lingua del link precedente.

Categorie impostate dal modulo[modifica]

Il modulo inserisce automaticamente alcune categorie, sia quando è richiamato tramite template che quando direttamente con un #invoke.

In tutte le pagine[modifica]

  • Nelle pagine del namespace principale che visualizzano un box :
Categoria:Articoli con box interwiki verso _Progetto_
  • Nelle pagine di namespace diversi da quello principale che visualizzano un box :
Categoria:Pagine con box interwiki verso _Progetto_

Dove _Progetto_ viene sostituito dal testo del parametro progetto. Queste categorie, raccolte sotto la categoria madre Categoria:Pagine con box interwiki e impostate come __HIODDENCAT__, permettono di far manutenzione e tener d'occhio quantità e distribuzione dei box che linkano verso altri progetti.

  • Nelle pagine in cui il modulo genera un errore :
Categoria:Pagine con errori in box interwiki

Testo da inserire nelle pagine delle categorie :

__HIDDENCAT__
{{ServizioVuota}}

[[Categoria:Pagine con box interwiki]]

Nelle pagine dei template derivati[modifica]

  • Nelle pagine dei template che richiamano il modulo, purché il box vi sia visualizzato :
Categoria:Template Wikimedia
Categoria:Template basati su Modulo:Box interwiki

Se, per qualsiasi motivo, il template non visualizza il box nella propria pagina ( per esempio perché la chiamata di #invoke è sotto una condizione non verificata quando i parametri non sono valorizzati ), si può ottenere la categorizzazione del template tramite un box nel manuale del template.

Test nella console di debug[modifica]

Il seguente codice può essere inserito nella console di debug ( disponibile durante l'editing del modulo ) per testare l'output di una chiamata all'ipotetico template derivato definito dai valori nel secondo args = { ... }, mentre i valori nel primo args = { ... } simulano i parametri nella chiamata al template derivato.

I primi due valori nel primo args = { ... } sono ininfluenti, solo i valori dal terzo in poi vengono letti dal modulo. L'eventuale uso che il template farà dei primi due valori, andrà simulato inserendo direttamente i valori risultanti nei parametri del secondo args = { ... }, che simula la chiamata a #invoke.

= p.getBox(
    mw.getCurrentFrame()
    :newChild{ args = {
        '', '' -- , '', ''
    } }
    :newChild{ args = {
        pagina                     = 'page',
        progetto                   = 'project',
        prefisso                   = 'pref',
        immagine                   = 'image.svg',
        [ 'etichetta-pagina' ]     = nil,
        lingua                     = nil,
        [ 'progetto-multilingue' ] = nil,
        [ 'dimensione-immagine' ]  = nil,
        [ 'una-pagina' ]           = nil,
        [ 'pre-progetto' ]         = nil,
        [ 'pre-pagina' ]           = nil,
        [ 'pre-pagina-multi' ]     = nil,
        [ 'multi-pagina-come' ]    = nil,
        [ 'parametri-riservati' ]  = nil
    } }
)

Il seguente codice permette di visualizzare il risultato della chiamata di un template già esistente basato sul modulo.

ATTENZIONE: questo secondo codice, a differenza del precedente, utilizza l'ultima versione salvata del modulo, non quella contenuta nella casella di modifica.

= mw.getCurrentFrame()
:expandTemplate{
    title = 'Wikipedia',    -- nome del template
    args = { 'An article' } -- parametri passati al template
}

--[[

ATTENZIONE: il codice contiene riferimenti al nome del modulo
WARNING: module's code contains references to module's name

******
**
**  ==  Modulo:Box interwiki  ==
**
**  Questo modulo implementa le funzionalità
**  di alcuni dei template per i box con collegamenti interwiki
**  contenuti nella Categoria:Template_Wikimedia
**
**  This module implements the functionality
**  of some templates for interwiki link boxes
**  contained in Category:Template_Wikimedia
**
********

]]

local p = {}

-- #invoke parameters
local pagina, etichettaPagina, lingua
local progetto, prefisso, progettoMultilingue
local immagine, dimImmagine
local unaPagina, preProgetto, prePagina
local prePaginaMulti, multiPageMode, templateBoundArgs

-- other variables
local currentFrame, parentFrameArgs, multiLink
local defaultLang = 'it'


-- utility functions
local function isParameterSet( par )

    return
    par ~= nil
    and
    mw.text.trim( par ) ~= ''

end
local function getValueOrDefault( parameterName, default, fromTemplate )

    -- if fromTemplate, the value provided by the template call
    -- will supersede the one set by #invoke

    local value =
    fromTemplate
    and parentFrameArgs[ parameterName ]
    or  currentFrame.args[ parameterName ]

    value = value and mw.text.trim( value )

    if default and not isParameterSet( value )
    then return default
    else return value
    end

end

-- text-chunks builder functions
local function errorIfMissingPars()

    if  (
    not isParameterSet( pagina )
    or not isParameterSet( progetto )
    or not isParameterSet( prefisso )
    or not isParameterSet( immagine )
    )
    then return [=[
    
<div class="error" margin:2em;>
Errore nell'#invoke al [[Modulo:Box interwiki]].

I seguenti parametri devono essere sempre valorizzati&nbsp;:
* pagina
* progetto
* prefisso
* immagine
</div>
[[Categoria:Pagine con errori in box interwiki|_]]
]=]
    else return nil
    end

end
local function mainDivTag()

    return [[
<div
    style="
        clear: right;
        float: right;
        width: 22em;
        border: solid #aaa 1px;
        padding: .4em;
        margin: 0 0 .5em 1em;
        font-size: 90%;
        text-align: left;
        background: #f9f9f9;
    "
>
]]

end
local function imageEmbed()

    return
    '[[File:'
    ..    immagine
    ..    '|' .. dimImmagine
    ..    '|left'
    ..    '|logo ' .. progetto
    .. ']]\n'


end
local function projectWikilink()

    -- link to project's Wikipedia article
    -- if links can be in multiple languages
    if multiLink
    and string.find( multiPageMode, 'lingua' )
    then return
        "'''[["
        ..      'w'
        ..      ':'
        ..      progetto
        .. '|'
        ..      progetto
        .. "]]'''"
    end

    -- else link to project's Main page

    local mainPageEn = 'Main Page'
    local mainPageIt = 'Pagina principale'

    local mainPage = (
    isParameterSet( progettoMultilingue )
    and mainPageEn
    or mainPageIt
    )

    if lingua ~= defaultLang
    then return
        "'''[["
        ..     prefisso
        ..     ':'
        ..     lingua
        ..     ':'
        ..     mainPageEn
        .. '|'
        ..     progetto
        .. "]]'''"
        .. ' in '
        .. mw.language.fetchLanguageName( lingua, 'it' )
    else return
        "'''[["
        ..     prefisso
        ..     ':'
        ..     mainPage
        .. '|'
        ..     progetto
        .. "]]'''"
    end

end
local function beforePage()

    if multiLink
    then
        return ' ' .. prePaginaMulti .. ' '
    else
        if isParameterSet( prePagina ) then
            return ' ' .. prePagina .. ' '
        else
            return ' ha ' .. unaPagina .. ' su '
        end
    end

end
local function pageWikilink( prefix, lang, page, pageLabel, showLang )

    local label = (
    isParameterSet( pageLabel )
    and pageLabel
    or page
    )

    if showLang and lang ~= defaultLang
    then label = lang .. ':' .. label
    end

    if isParameterSet( lang ) and lang ~= defaultLang
    then return
        "'''[["
        ..     prefix
        ..     ':'
        ..     lang
        ..     ':'
        ..     page
        .. '|'
        ..     label
        .. "]]'''"
    else return
        "'''[["
        ..     prefix
        ..     ':'
        ..     page
        .. '|'
        ..     label
        .. "]]'''"
    end

end
local function otherPagesWikilinks()

    if not multiLink then
        return ''
    end

    local otherWikilinks = ''
    local separator = " '''·''' "

    local function addWikilink( prefix, lang, page, pageLabel, showLang )

        otherWikilinks = otherWikilinks
        .. separator
        .. pageWikilink( prefix, lang, page, pageLabel, showLang )

    end

    local lang = lingua
    local page, pageLabel
    local firstOfTwo = ( templateBoundArgs + 1 ) % 2
    local firstOfThree = ( templateBoundArgs + 1 ) % 3
    local secondOfThree = ( templateBoundArgs + 2 ) % 3
    local lastPos

    if multiPageMode == 'pagine' then
        for pos, pageTitle in ipairs( parentFrameArgs ) do
            if pos > templateBoundArgs then
                pageTitle = mw.text.trim( pageTitle )
                addWikilink( prefisso, lingua, pageTitle )
            end
        end
    elseif multiPageMode == 'pagina-etichetta' then
        for pos, item in ipairs( parentFrameArgs ) do
            item = mw.text.trim( item )
            lastPos = pos
            if pos > templateBoundArgs then
                if pos % 2 == firstOfTwo then
                    page = item
                else
                    pageLabel = item
                    addWikilink( prefisso, lingua, page, pageLabel )
                end
            end
        end
        if lastPos % 2 == firstOfTwo then
            addWikilink( prefisso, lingua, page )
        end
    elseif multiPageMode == 'lingua-pagina' then
        for pos, item in ipairs( parentFrameArgs ) do
            item = mw.text.trim( item )
            if pos > templateBoundArgs then
                if pos % 2 == firstOfTwo then
                    lang = isParameterSet( item ) and item or lang
                else
                    page = item
                    addWikilink( prefisso, lang, page, nil, true )
                end
            end
        end
    elseif multiPageMode == 'lingua-pagina-etichetta' then
        for pos, item in ipairs( parentFrameArgs ) do
            item = mw.text.trim( item )
            lastPos = pos
            if pos > templateBoundArgs then
                if pos % 3 == firstOfThree then
                    lang = isParameterSet( item ) and item or lang
                elseif pos % 3 == secondOfThree then
                    page = item
                else
                    pageLabel = item
                    addWikilink( prefisso, lang, page, pageLabel, true )
                end
            end
        end
        if lastPos % 3 == secondOfThree then
            addWikilink( prefisso, lang, page, page, true )
        end
    end

    return otherWikilinks

end
local function pageCategories()

    local currentTitle, pageNamespace, pageType
    local pageCategory, piping
    local templateCategory = ''

    currentTitle  = mw.title.getCurrentTitle()
    pageNamespace = currentTitle.namespace

    if pageNamespace == 0
    then
        pageType = 'Articoli'
        piping = ''
    else
        pageType = 'Pagine'
        piping = '|' .. currentTitle.prefixedText
    end

    pageCategory =
    '[[Categoria:'
    ..     pageType
    ..     ' con box interwiki verso '
    ..     progetto
    ..     piping
    .. ']]'

    if pageNamespace == 10
    then
        if mw.ustring.match(
        currentTitle:getContent() or '', -- or '' is for new pages previews
        '{{%s*#invoke:%s*[bB]ox[ _]interwiki%s*|%s*getBox[%s|]',
        0
        )
        then
            templateCategory = [=[

[[Categoria:Template Wikimedia]]
[[Categoria:Template basati su Modulo:Box interwiki]]
]=]
        end
    end

    return
    '\n'
    .. pageCategory
    .. templateCategory

end

-- function for #invoke
function p.getBox( frame )

    currentFrame    = frame
    parentFrameArgs = frame:getParent().args

    -- mandatory #invoke parameters
    pagina   = getValueOrDefault( 'pagina'   )
    progetto = getValueOrDefault( 'progetto' )
    prefisso = getValueOrDefault( 'prefisso' )
    immagine = getValueOrDefault( 'immagine' )

    -- returns an error message if any mandatory parameter is missing
    local error = errorIfMissingPars()
    if error
    then return error
    end

    -- optional #invoke parameters
    etichettaPagina     = getValueOrDefault( 'etichetta-pagina'     , nil               , true )
    lingua              = getValueOrDefault( 'lingua'               , defaultLang       )
    progettoMultilingue = getValueOrDefault( 'progetto-multilingue' , nil               )
    dimImmagine         = getValueOrDefault( 'dimensione-immagine'  , 'x55px'           )
    unaPagina           = getValueOrDefault( 'una-pagina'           , 'una pagina'      )
    preProgetto         = getValueOrDefault( 'pre-progetto'         , ''                )
    prePagina           = getValueOrDefault( 'pre-pagina'           , nil               )
    prePaginaMulti      = getValueOrDefault( 'pre-pagina-multi'     , ' ha le pagine: ' )
    multiPageMode       = getValueOrDefault( 'multi-pagina-come'    , 'pagine'          , true )
    templateBoundArgs   = getValueOrDefault( 'parametri-riservati'  , 2                 )

    -- parameters' fixes

    templateBoundArgs = tonumber( templateBoundArgs )

    if progettoMultilingue
    then
        if multiPageMode == 'lingua-pagina' then
            multiPageMode = 'pagine'
        elseif multiPageMode == 'lingua-pagina-etichetta' then
            multiPageMode = 'pagina-etichetta'
        end
    end

    if preProgetto ~= ''
    then preProgetto = preProgetto .. ' '
    end

    multiLink = parentFrameArgs[ 1 + templateBoundArgs ] ~= nil

    -- returning wikitext
    return
    mainDivTag() -- <div ...>
    ..      imageEmbed()
    ..      preProgetto
    ..      projectWikilink()
    ..      beforePage()
    ..      pageWikilink( prefisso, lingua, pagina, etichettaPagina )
    ..      otherPagesWikilinks()
    .. '.\n</div>'
    .. pageCategories()

end


return p