Modul:Vorlage:Handle

--[=[ 2014-12-13 Template:Handle Vorlage:HDL ]=]

local Config = {

  parProblem  = "problem",
  scheme      = false,
  doi         = { showArticle = "Digital Object Identifier",
                  showName    = "DOI",
                  stemURL     = "//dx.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)" }

}

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 = 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 fault( 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 story = factory( alert )
   local r, scope, style
   if add then
       story = string.format( "%s %s", story, add )
   end
   if not Config.frame then
       Config.frame = mw.getCurrentFrame()
   end
   if Config.frame:preprocess( "4036" ) == "" 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( "%s",
                      scope, style, story )
   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 -- fault()

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 = fault( "errUnkown", r )
   else
       local lucky, util = pcall( require, "Module:URIutil" );
       if lucky then
           if type( util ) == "table" then
               util = util.URIutil();
           else
               util = "library URIutil invalid";
           end
       end
       if type( util ) ~= "table" then
           error( util, 0 );
       end
       if util[ "is" .. Config.showName ]( access )  then
           r = util[ "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 = fault( "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 = fault( "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 = string.format( "%s * %s",
                          frame:getTitle(),
                          r )
   end
   return r

end -- p.f()

return p