Zum Inhalt springen

Modul:Namespace detect: Unterschied zwischen den Versionen

Modul:Namespace detect (Quelltext anzeigen)

Version vom 1. Juli 2013, 12:01 Uhr

2.111 Bytes hinzugefügt ,  vor 12 Jahren
make some of the functions public for use in Module:Category handler, redo compare() code, use local variables instead of globals where possible
K (Protected Module:Namespace detect: High-risk Lua module ([Edit=Block all non-admin users] (indefinite) [Move=Block all non-admin users] (indefinite)))
(make some of the functions public for use in Module:Category handler, redo compare() code, use local variables instead of globals where possible)
Zeile 48: Zeile 48:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- Specify variables available to the whole module
----------------------------------------------------------------------
--                        Global functions                          --
--      The following functions are global, because we want them    --
--      to be accessible from other Lua modules called using        --
--      require().                                                  --
----------------------------------------------------------------------
 
-- Declare the table of functions to return.
local p = {}
local p = {}
local args = {}


-- Get the page object. This will return the page object for the page
-- Get the page object. This will return the page object for the page
-- specified, or nil if there are errors in the title or if the
-- specified, or nil if there are errors in the title or if the
-- expensive function count has been exceeded.
-- expensive function count has been exceeded.
local function getPageObject()
function p.getPageObject( page )
     -- Get the title object for args.page if it is specified. Otherwise
     -- Get the title object for args.page if it is specified. Otherwise
     -- get the title object for the current page.
     -- get the title object for the current page.
     if args[cfg.page] then
     if page then
         -- Get the page object, passing the function through pcall  
         -- Get the page object, passing the function through pcall  
         -- in case we are over the expensive function count limit.
         -- in case we are over the expensive function count limit.
         local noError, pageObject = pcall(mw.title.new, args[cfg.page])
         local noError, pageObject = pcall(mw.title.new, page)
         if not noError then
         if not noError then
             return nil
             return nil
Zeile 72: Zeile 78:
end
end


-- Detects the namespace for a page object.
--[[ Returns a table of how parameter names map to namespace names.
local function detectNamespace(pageObject)
The keys are the actual namespace names, in lower case, and the
     if pageObject.isTalkPage then
values are the possible parameter names for that namespace, also
         -- Returns the value of cfg.talk or the local "Talk" namespace name.  
in lower case. The table entries are structured like this:
         return cfg.talk or mw.site.namespaces[1].name
    [''] = {
     else
        {'main'},
         return pageObject.nsText
    },
    ['wikipedia'] = {
        {'wikipedia', 'project', 'wp' }
    }
]]
function p.getParamMappings()
    local mappings = {}
    mappings[mw.ustring.lower( mw.site.namespaces[0].name )] = { cfg.main }
     mappings[cfg.talk] = { cfg.talk }
    for nsid, ns in pairs( mw.site.subjectNamespaces ) do
        if nsid ~= 0 then -- Exclude main namespace.
            local nsname = mw.ustring.lower( ns.name )
            local canonicalName = mw.ustring.lower( ns.canonicalName )
            mappings[nsname] = { nsname }
            if canonicalName ~= nsname then
                table.insert( mappings[nsname], canonicalName )
            end
            for _, alias in ipairs( ns.aliases ) do
                table.insert( mappings[nsname], mw.ustring.lower( alias ) )
            end
         end
    end
    return mappings
end
 
--[[ Create a wikitable of all subject namespace parameters, for documentation
  purposes. Talk is excluded, as it should usually be treated separately in
  the documentation.
]]
function p.table()
    -- Get the parameter mappings.
    local mappings = p.getParamMappings()
   
    -- Start the wikitable.
    local ret = '{| class="wikitable"'
        .. '\n|-'
        .. '\n! ' .. cfg.wikitableNamespaceHeader
        .. '\n! ' .. cfg.wikitableAliasesHeader
   
    -- Generate the row for the main namespace, as we want this
    -- to be first in the list.
    ret = ret .. '\n|-'
         .. '\n| <code>' .. cfg.main .. '</code>'
        .. '\n|'
       
    -- Enclose all parameter names in <code> tags.
    for ns, params in pairs( mappings ) do
        if ns ~= mw.site.namespaces[0].name then
            for i, param in ipairs( params ) do
                mappings[ns][i] = '<code>' .. param .. '</code>'
            end
        end
    end
   
     -- Generate the other wikitable rows.
    for ns, params in pairs( mappings ) do
         if ns ~= mw.site.namespaces[0].name then -- Ignore the main namespace.
            ret = ret .. '\n|-'
                .. '\n| ' .. params[1]
                .. '\n| ' .. table.concat( params, ', ', 2 )
        end
     end
     end
   
    -- End the wikitable.
    ret = ret .. '\n|-'
        .. '\n|}'
   
    return ret
end
end
----------------------------------------------------------------------
--                        Local functions                          --
--      The following are internal functions, which we do not want  --
--      to be accessible from other modules.                        --
----------------------------------------------------------------------


-- Gets the namespace name to compare to the arguments. The returned value
-- Gets the namespace name to compare to the arguments. The returned value
-- is lower-case.
-- is lower-case.
local function getNamespace()
local function getNamespace( page, demospace )
     local ret
     local ret
     if args[cfg.demospace] then
     if demospace then
         -- Handle "demospace = main" properly.
         -- Handle "demospace = main" properly.
         if mw.ustring.lower( args[cfg.demospace] ) == cfg.main then
         if mw.ustring.lower( demospace ) == cfg.main then
             ret = mw.site.namespaces[0].name
             ret = mw.site.namespaces[0].name
         else
         else
             ret = args[cfg.demospace]
             ret = demospace
         end
         end
     else
     else
         local pageObject = getPageObject()
         local pageObject = p.getPageObject( page )
         if pageObject then
         if pageObject then
             ret = detectNamespace( getPageObject() )
             if pageObject.isTalkPage then
                -- {{namespace detect}} uses the same value for all talk
                -- namespaces, so that's what the module should do too.
                ret = cfg.talk
            else
                ret = pageObject.nsText
            end
         else
         else
             return nil -- return nil if the page object doesn't exist.
             return nil -- return nil if the page object doesn't exist.
Zeile 106: Zeile 190:
-- Compare the namespace found with the parameters that have been
-- Compare the namespace found with the parameters that have been
-- specified, and return content of the appropriate parameter.
-- specified, and return content of the appropriate parameter.
local function compare()
local function compare( args )
     local namespace = getNamespace()
     -- Get the namespace to compare the parameters to, and the parameter
   
     -- mapping table.
     -- First, compare mainspace parameters.
     local namespace = getNamespace( args[cfg.page], args[cfg.demospace] )
     if namespace == mw.site.namespaces[0].name and args[cfg.main] then
     local mappings = p.getParamMappings()
        return args[cfg.main]
     end
      
      
     -- Next, compare parameters for non-main namespaces.
     -- Check for any matches in the namespace arguments. The order we check
     for nsid, ns in pairs( mw.site.namespaces ) do
    -- them doesn't matter, as there can only be one match.
         local nsname = mw.ustring.lower( ns.name )
     for ns, params in pairs( mappings ) do
        local canonicalName = mw.ustring.lower( ns.canonicalName )
         if ns == namespace then
        -- Check the namespace, and ignore main namespace values.
             -- Check all aliases for matches. The default local namespace is
        if nsid ~= 0 and nsname == namespace then
             -- checked first, as {{namespace detect}} checked these before
             -- Check local namespace name.
             -- alias names.
            if args[nsname] then
            for _, param in ipairs( params ) do
                return args[nsname]
                if args[param] then
             -- Check canonical namespace name.
                     return args[param]
             elseif args[canonicalName] then
                return args[canonicalName]
            else
                -- Check alias names.
                for _, alias in ipairs( ns.aliases ) do
                    local aliasArg = args[ mw.ustring.lower( alias ) ]
                     if aliasArg then
                        return aliasArg
                    end
                 end
                 end
             end
             end
Zeile 138: Zeile 211:
     end
     end
      
      
     -- Finally, return parameters for other namespaces. This happens if
     -- If there were no matches, return parameters for other namespaces.  
     -- there was no text specified for the namespace that was detected
     -- This happens if there was no text specified for the namespace that
     -- or if the demospace parameter is not a valid namespace. Note that
     -- was detected or if the demospace parameter is not a valid namespace.
     -- the parameter for the detected namespace must be completely
     -- Note that the parameter for the detected namespace must be completely
     -- absent for this to happen, not merely blank.
     -- absent for this to happen, not merely blank.
     if args[cfg.other] then
     if args[cfg.other] then
Zeile 148: Zeile 221:
end
end


-- Process the arguments.
----------------------------------------------------------------------
--                            Main function                        --
--      This is the function that will be most used. It processes  --
--      the arguments and calls the compare() function. It is      --
--      global, but is put down here as it depends on the other    --
--      local in order for it to work.                             --
----------------------------------------------------------------------
 
function p.main(frame)
function p.main(frame)
     -- If called via #invoke, use the args passed into the invoking
     -- If called via #invoke, use the args passed into the invoking
Zeile 166: Zeile 246:
     -- Trim whitespace and remove blank arguments for demospace and  
     -- Trim whitespace and remove blank arguments for demospace and  
     -- page parameters.
     -- page parameters.
    local args = {}
     for k, v in pairs(origArgs) do
     for k, v in pairs(origArgs) do
         v = mw.text.trim(v) -- Trim whitespace.
         v = mw.text.trim(v) -- Trim whitespace.
Zeile 177: Zeile 258:
     end
     end
      
      
     return compare()
     return compare(args)
end
 
-- Create a wikitable of all possible namespace parameters.
function p.table()
    -- Start the wikitable.
    local ret = '{| class="wikitable"'
        .. '\n|-'
        .. '\n! ' .. cfg.wikitableNamespaceHeader
        .. '\n! ' .. cfg.wikitableAliasesHeader
   
    -- Generate the row for the main namespace.
    ret = ret .. '\n|-'
        .. '\n| ' .. cfg.main
        .. '\n|'
   
    -- Generate the other wikitable rows.
    for nsid, ns in pairs( mw.site.subjectNamespaces ) do
        if nsid ~= 0 then -- Ignore the main namespace, as it is set in cfg.
            local name = '<code>' .. mw.ustring.lower( ns.name ) .. '</code>'
            local aliases = {}
            if ns.canonicalName ~= ns.name then
                table.insert( aliases, '<code>' .. mw.ustring.lower( ns.canonicalName ) .. '</code>' )
            end
            for _, v in ipairs( ns.aliases ) do
                table.insert( aliases, '<code>' .. mw.ustring.lower(v) .. '</code>' )
            end
            ret = ret .. '\n|-'
                .. '\n| ' .. name
                .. '\n| ' .. table.concat( aliases, ', ' )
        end
    end
   
    -- End the wikitable.
    ret = ret .. '\n|-'
        .. '\n|}'
   
    return ret
end
end


return p
return p
Abgerufen von „https://skandinavien-wiki.net/wiki/Spezial:Mobiler_Unterschied/12580“