Modul:Vorlage:Handle

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

--[=[
Template:Handle   {{DOI}} {{HDL}}
require: URIutil
]=]



local Config = {
   parProblem  = "problem",
   scheme      = false,
   doi         = { showArticle = "Digital Object Identifier",
                   showName    = "DOI",
                   stemURL     = "//doi.org/" },
   hdl         = { showArticle = false,
                   showName    = "Handle",
                   stemURL     = "//hdl.handle.net/" },
   errCat      = false,
   errClass    = "error_Handle",
   errClasses  = false,
   errHide     = false,
   errNS       = false,
   errInvalid  = { en = "Invalid:",
                   de = "Ungültig:" },
   errScheme   = { en = "Bad #invoke|scheme=" },
   errUnkown   = { en = "Unkown parameter:",
                   de = "Parameter unbekannt:" },
   problemNote = { en = "(currently unavailable)",
                   de = "(zurzeit nicht erreichbar)" }
}



Config.fault = function ( alert )
    -- Format error message by class=error
    -- Parameter:
    --     alert  -- string, error message
    -- Returns:
    --     string, HTML span
    return tostring( mw.html.create( "span" )
                            :addClass( "error" )
                            :wikitext( alert ) )
end -- Config.fault()



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[ mw.language.getContentLanguage():getCode() ]
        if not r then
            r = entry.en
        end
    else
        r = Config.fault( string.format( "????.%s.????", apply ) )
    end
    return r
end -- factory()



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



local function failed( alert, add )
    -- Format message with class="error" or similar
    --     alert  -- string, with message key
    --     add    -- string, with additional information, or nil
    -- Returns message with markup
    local lucky, TemplUtl = pcall( require, "Module:TemplUtl" )
    local scope = Config.errClass
    local story = factory( alert )
    local r
    if add then
        story = string.format( "%s %s", story, add )
    end
    if Config.errClasses then
        scope = string.format( "%s %s", scope, Config.errClasses )
    end
    if type( TemplUtl ) == "table" then
        TemplUtl = TemplUtl.TemplUtl()
    end
    if type( TemplUtl ) == "table"  and
       type( TemplUtl.failure ) == "function" then
        r = TemplUtl.failure( story,
                              not Config.errHide,
                              scope,
                              Config.frame )
    else
        -- LEGACY and global wiki mode
        local element = mw.html.create( "span" )
                               :addClass( scope )
        if not Config.frame then
            Config.frame = mw.getCurrentFrame()
        end
        if Config.frame:preprocess( "{{REVISIONID}}" ) == "" then
            Config.errCat  = false
            Config.errHide = false
            element:addClass( "error" )
        end
        if Config.errHide then
            element:css( "display", "none" )
        end
        r = tostring( element:wikitext( story ) )
    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 -- failed()



local function fiat( access, args )
    -- Format template request
    --     access  -- string, with trimmed ID
    --     args    -- table, with template parameters
    -- Returns appropriate string
    local r, unknown
    for k, v in pairs( args ) do
        if k ~= 1  and
           k ~= "demo"  and
           k ~= "NoCat"  and
           k ~= Config.parProblem then
            if not unknown then
                unknown = { }
            end
            table.insert( unknown, k )
        end
    end -- for k, v
    if args.demo  or  faculty( args.NoCat ) then
        Config.errCat  = false
        Config.errHide = false
    end
    if unknown then
        r = string.format( "'<code>%s</code>' in Template:%s",
                           table.concat( unknown, " " ),
                           Config.scheme )
        r = failed( "errUnkown", r )
    else
        local lucky, URIutil = pcall( require, "Module:URIutil" )
        if lucky then
            if type( URIutil ) == "table" then
                URIutil = URIutil.URIutil()
            else
                URIutil = "library URIutil invalid"
            end
        end
        if type( URIutil ) ~= "table" then
            error( URIutil, 0 )
        end
        if URIutil[ "is" .. Config.showName ]( access )  then
            r = URIutil[ "link" .. Config.showName ]( access )
            if Config.showArticle then
                r = string.format( "[[%s|%s]]:%s",
                                   Config.showArticle, Config.scheme, r )
            else
                r = string.format( "%s:%s", Config.scheme, r )
            end
            if args[ Config.parProblem ] then
                r = string.format( "%s <small>%s</small>",
                                   r,  factory( "problemNote" ) )
            end
        else
            r = failed( "errInvalid",
                        string.format( "%s=%s",
                                       Config.showName,
                                       mw.text.nowiki( access ) ) )
        end
    end
    return r
end -- fiat()



-- Export
local p = { }

p.main = function ( argsF, argsT )
    -- Invocation; decide between first and secondary processing
    --     argsF  -- table, with #invoke parameters
    --     argsT  -- table, with template parameters
    -- Returns appropriate string
    local r = argsT[ 1 ]
    if r then
        local cnf = Config[ argsF.scheme ]
        if cnf then
            r = mw.text.trim( r )
            if r == ""  or
               r:find( cnf.stemURL, 1, true )  or
               r:find( Config.errClass, 1, true ) then
                argsF = false
            elseif r:find( "[[", 1, true ) then
                local seek = "%[%[%s*" .. argsF.scheme .. ":"
                if r:lower():find( seek ) then
                    argsF = false
                end
            end
            if argsF then
                Config.errCat     = argsF.errCat
                Config.errClasses = argsF.errClasses
                Config.errHide    = faculty( argsF.errHide )
                Config.errNS      = argsF.errNS
                if argsF.parProblem then
                    Config.parProblem = argsF.parProblem
                end
                Config.scheme = argsF.scheme
                if argsF.showArticle then
                    if argsF.showArticle == "" then
                        Config.showArticle = false
                    else
                        Config.showArticle = argsF.showArticle
                    end
                else
                    Config.showArticle = cnf.showArticle
                end
                Config.showName = cnf.showName
                r               = fiat( r, argsT )
            end
        else
            Config.errHide  = false
            Config.errClass = "error"
            r = failed( "errScheme", argsF.scheme )
        end
    else
        r = ""
    end
    return r
end -- p.main()



p.f = function ( frame )
    local lucky, r
    Config.frame = frame
    lucky, r = pcall( p.main, frame.args, frame:getParent().args )
    if not lucky then
        r = Config.fault( string.format( "%s * %s",
                                         frame:getTitle(), r ) )
    end
    return r
end -- p.f()



function p.failsafe()
    return Serial
end -- p.failsafe()

return p