Modul:Vorlage:Handle

local Serial = "2018-01-10" --[=[ Template:Handle Vorlage: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( "4040" ) == "" 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", 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( "'%s' 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",
                                  Config.showArticle, Config.scheme, r )
           else
               r = string.format( "%s:%s", Config.scheme, r )
           end
           if args[ Config.parProblem ] then
               r = string.format( "%s %s",
                                  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