Modul:Vorlage:lang

Die Dokumentation für dieses Modul kann unter Modul:Vorlage:lang/Doku erstellt werden

local Export = { serial = "2016-07-21",
                 suite  = "lang" }
--[=[
Vorlage:lang und Sprachnamenvorlagen unterstützen
]=]



local Config = {
   self           = Export.suite,
   errCat         = false,
   errClass       = "error_lang",
   errClasses     = false,
   errHide        = false,
   errNS          = false,
   errDoubled     = { en = "Doubled:",
                      de = "Doppelangabe:" },
   errInvalid     = { en = "Invalid:",
                      de = "Ungültig:" },
   errMissing     = { en = "Missing parameter",
                      de = "Parameter fehlt" },
   errUnkown      = { en = "Unkown parameter:",
                      de = "Parameter unbekannt:" },
   audio          = "Audio",
   ipa            = "IPA2",
   params         = { "Text1",
                      "Text2",
                      "Audio",
                      "IPA",
                      "de",            -- [b=]
                      "en",
                      "style",
                      "nachgestellt",
                      "demo",
                      "NoCat" },
   translations   = { de = { en = "German: %s",
                             de = "deutsch ‚%s‘" },
                      en = { en = "English: %s",
                             de = "englisch ''%s''" }
                    },
   transcriptions =
       { Arab = { en = "[[Arabic alphabet|arabic]]",
                  de = "[[Arabisches Alphabet|arabisch]]" },
         Cyrl = { en = "[[Cyrillic alphabets|cyrillic]]",
                  de = "[[Kyrillisches Alphabet|kyrillisch]]" }
       }
}



local function facility()
    -- Fetch current site language
    -- Returns language code
    if not Config.standard then
        Config.standard = mw.language.getContentLanguage():getCode()
    end
    return Config.standard
end -- facility()



local function factory( apply )
    -- Localization of messages
    --     apply  -- string, with message key
    -- Returns message text; at least english
    local r
    entry = Config[ apply ]
    if entry then
        r = entry[ facility() ]
        if not r then
            r = entry.en
        end
    else
        r = string.format( "<span class=\"error\">????.%s.????</span>",
                           apply )
    end
    return r
end -- factory()



local function faculty( adjust )
    -- Test template arg for boolean
    --     adjust  -- string or nil
    -- Returns boolean
    local s = type( adjust )
    local r
    if s == "string" then
        r = mw.text.trim( adjust )
        r = ( r ~= ""  and  r ~= "0" )
    elseif s == "boolean" then
        r = adjust
    else
        r = false
    end
    return r
end -- faculty()



local function fault( alert, about )
    -- Format message with class="error" or similar
    --     alert  -- string, with message key
    --     about  -- string, with explanation
    -- Returns message with markup
    local story = factory( alert )
    local r, scope, style
    if Config.self then
        story = string.format( "%s * %s", Config.self, story )
    end
    if not Config.frame then
        Config.frame = mw.getCurrentFrame()
    end
    if Config.frame:preprocess( "{{REVISIONID}}" ) == "" then
        Config.errCat  = false
        Config.errHide = false
        scope          = string.format( "%s error", Config.errClass )
    else
        scope = Config.errClass
    end
    if Config.errHide then
        style = "style='display:none'"
    else
        style = ""
    end
    if Config.errClasses then
        scope = string.format( "%s %s",
                               scope, Config.errClasses )
    end
    r = string.format( "<span class=\"%s\" %s>%s</span>",
                       scope, style, story )
    if about then
        r = string.format( "%s %s", r, about )
    end
    if Config.errCat then
        if Config.errNS then
            local ns = mw.title.getCurrentTitle().namespace
            local st = type( Config.errNS )
            if st == "string" then
                local space  = string.format( ".*%%s%d%%s.*", ns )
                local spaces = string.format( " %s ", Config.errNS )
                if spaces:match( space ) then
                    Config.errNS = false
                end
            elseif st == "table" then
                for i = 1, #Config.errNS do
                    if Config.errNS[ i ] == ns then
                        Config.errNS = false
                        break    -- for i
                    end
                end -- for i
            end
        end
        if not Config.errNS then
            r = string.format( "%s[[Category:%s]]", r, Config.errCat )
        end
    end
    return r
end -- fault()



local function fetch( auxilary )
    -- Fetch module
    --     auxilary  -- Multilingual library, or false
    -- Returns table of library, or string with error message
    local r = auxilary
    if type( r ) ~= "table" then
        local lucky
        lucky, r = pcall( require, "Module:Multilingual" )
        if type( r ) == "table" then
            r = r.Multilingual()
        else
            r = string.format( "<span class=\"error\">%s</span>", r )
        end
    end
    return r
end -- fetch()



local function flat( argsF, argsT )
    -- Invocation of basic language template
    --     argsT  -- table, with parameters
    -- Returns appropriate string
    local slang = argsT[ 1 ]
    local show  = argsT[ 2 ]
    local r
    if argsF then
        Config.errCat  = argsF.errCat
        Config.errHide = faculty( argsF.errHide )
        Config.errNS   = argsF.errNS
    end
    if slang then
        slang = mw.text.trim( slang )
        if slang == "" then
            slang = false
        end
    end
    if show then
        show = mw.text.trim( show )
        if show == "" then
            show = false
        end
    end
    if slang and show then
        local e = mw.html.create( "span" )
                         :attr( "lang", slang )
                         :wikitext( show )
        r = tostring( e )
        -- syntax check on slang
    else
        r = fault( "errMissing" )
        if show then
            r = show .. r
        end
    end
    return r
end -- flat()



local function frame()
    -- Fetch current frame
    -- Returns frame
    if not Config.frame then
        Config.frame = mw.getCurrentFrame()
    end
    return Config.frame
end -- frame()



local function full( arglist )
    -- Invocation of language name template
    --     arglist  -- table, with parameters
    -- Returns appropriate string
    local r
    if arglist.Text1 then
        local slang = Config.slang
        local params, s
        if Config.scripting == "Latn" then
            if slang == facility() then
                arglist.style = false
            else
                arglist.style = arglist.style or "font-style:italic"
            end
            if arglist.Text2 then
                arglist.Text2 = fault( "errInvalid", "Latn+2=" )
            end
        else
            arglist.style = arglist.style or "font-style:normal"
        end
        if Config.long and Config.scripting then
            slang = string.format( "%s-%s", slang, Config.scripting )
        end
        r = Export.format( slang,
                           arglist.Text1,
                           arglist.style,
                           arglist.Audio )
        if arglist.Text2 then
            params = { lang  = string.format( "%s-Latn",
                                              Config.slang ),
                       style = "font-style:italic" }
            s = mw.text.tag( "span", params, arglist.Text2 )
            r = string.format( "%s %s", r, s )
        end
        if Config.scripting then
            s = arglist[ Config.scripting ]
            if s  and
               faculty( s )  and
               not arglist.Text2  and
               Config.transcriptions[ Config.scripting ] then
                s = facility()
                s = Config.transcriptions[ Config.scripting ][ s ]
            else
                s = Config.service
            end
        else
            s = Config.service
        end
        if arglist.later then
            r = string.format( "%s (%s)", r, s )
        else
            r = string.format( "%s %s", s, r )
        end
        if arglist.IPA then
            params = { [1] = arglist.IPA }
            s = frame():expandTemplate{ title = Config.ipa,
                                        args  = params }
            r = string.format( "%s, %s", r, s )
        end
        for k, v in pairs( Config.translations ) do
            if arglist[ k ] then
                if Config.slang == k  and  not Config.scripting then
                    s = fault( "errInvalid",  k .. "=" )
                else
                    s = Config.translations[ k ][ facility() ]
                    s = string.format( s, arglist[ k ] )
                end
                r = r .. s
            end
        end -- for k, v
    elseif arglist.Text2 then
        r = fault( "errInvalid", "2=" )
    else
        if Config.sole then
            r = Config.sole
        else
            r = Config.service
        end
    end
    return r
end -- full()



Export.failsafe = function ( assert )
    local r
    if not assert  or  assert <= Export.serial then
        r = Export.serial
    else
        r = false
    end
    return r
end -- Export.failsafe()



Export.format = function ( alien, apply, appear, audio )
    -- Markup foreign language text
    --     alien   -- string, with language code
    --     apply   -- string, with text
    --     appear  -- string, with additional CSS, or nil
    --     audio   -- string, with title of an audio file, or nil
    -- Returns appropriate string with HTML tag
    local params = { lang = alien }
    local r
    if appear then
        params.style = appear
    end
    r = mw.text.tag( "span", params, apply )
    if audio and Config.audio then
        params = { [1] = audio,
                   [2] = r }
        r = frame():expandTemplate{ title = Config.audio,
                                    args  = params }
    end
    return r
end -- Export.format()



Export.full = function ( argsF, argsT )
    -- Invocation of language name template
    --     argsF  -- table, with #invoke parameters, or false
    --     argsT  -- table, with template parameters
    -- Returns appropriate string
    local r = { }
    local s
    if argsF then
        Config.errCat     = argsF.errCat
        Config.errClasses = argsF.errClasses
        Config.errHide    = faculty( argsF.errHide )
        Config.errNS      = argsF.errNS
        Config.long       = faculty( argsF.LONG )
        Config.scripting  = argsF.SCRIPTING
        Config.service    = argsF.SERVICE
        Config.slang      = argsF.CODE
        Config.sole       = argsF.SOLE
        if argsF.SUITABLE then
            local params = mw.text.split( argsF.SUITABLE, " ", true )
            for k, v in pairs( params ) do
                table.insert( Config.params, k )
            end -- for k, v
        end
        if Config.scripting == "" then
            Config.scripting = false
        end
        if Config.scripting then
            table.insert( Config.params, Config.scripting )
        end
    end
    if type( argsT ) == "table" then
        local n = table.maxn( Config.params )
        local unknown
        for k, v in pairs( argsT ) do
            s = type( k )
            if s == "number" then
                if ( k <= 2 ) then
                    v = mw.text.trim( v )
                    k = string.format( "Text%d", k )
                else
                    k = tostring( k )
                end
            end
            for i = 1, n do
                if Config.params[ i ] == k then
                    if v ~= "" then
                        r[ k ] = v
                    end
                    k = false
                    break -- for i
                end
            end -- for i
            if k then
                if not unknown then
                    unknown = { }
                end
                table.insert( unknown, k )
            end
        end -- for k, v
        if r.demo  or  faculty( r.NoCat ) then
            Config.errCat  = false
            Config.errHide = false
        end
        r.later = faculty( r.nachgestellt )
        if r.b then
            if r.de then
                r = fault( "errDoubled", "'de=' und 'b='" )
            else
                r.de = r.b
            end
        end
        if unknown then
            r = string.format( "'<code>%s</code>' in Template:lang",
                               table.concat( unknown, " " ) )
            r = fault( "errUnkown", r )
        end
    end
    if type( r ) == "table" then
        r = full( r )
    end
    return r
end -- Export.full()



-- Export
local p = { }



p.test = function ( action, argsF, argsT )
    --     action  -- string, "flat" or "full"
    --     argsF   -- table, with #invoke parameters, or false
    --     argsT   -- table, with template parameters
    local r
    if action == "flat" then
        r = flat( argsF, argsT )
    elseif action == "full" then
        r = Export.full( argsF, argsT )
    end
    return r
end -- p.test()



p.flat = function ( frame )
    return flat( frame.args, frame:getParent().args )
end -- p.flat()



p.full = function ( frame )
    local lucky, r
    Config.frame = frame
    lucky, r = pcall( Export.full, frame.args, frame:getParent().args )
    if not lucky then
        r = string.format( "<span class=\"error\">%s * %s</span>",
                           frame:getTitle(), r )
    end
    return r
end -- p.full()



p.failsafe = function ( frame )
    local since = frame.args[ 1 ]
    if since then
        since = mw.text.trim( since )
        if since == "" then
            since = false
        end
    end
    return Export.failsafe( since )  or  ""
end -- p.failsafe()



p.lang = function ()
    return Export
end -- p.lang()

return p