Editing Module:DependencyList

Jump to navigation Jump to search
Warning: You are not logged in. Once you make an edit, a temporary account will be created for you. Learn more. Log in or create an account to continue receiving notifications after this account expires, and to access other features.
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.
Latest revision Your text
Line 1: Line 1:
require("strict")
-- <nowiki>
local p = {}
local p = {}
local libraryUtil = require('libraryUtil')
local libraryUtil = require( 'libraryUtil' )
local arr = require('Module:Array')
local enum = require( 'Module:Enum' )
local yn = require('Module:Yesno')
local yn = require( 'Module:Yesno' )
local param = require('Module:Paramtest')
local param = require( 'Module:Paramtest' )
local dpl = require('Module:DPLlua')
local dpl = require( 'Module:DPLlua' )
local tooltip = require('Module:Tooltip')
local tooltip = require( 'Module:Tooltip' )
local moduleIsUsed = false
local COLLAPSE_LIST_LENGTH_THRESHOLD = 5
local COLLAPSE_LIST_LENGTH_THRESHOLD = 5
local MAX_DYNAMIC_REQUIRE_LIST_LENGTH = 30
local MAX_DYNAMIC_REQUIRE_LIST_LENGTH = 30
local dynamicRequireListQueryCache = {}
local dynamicRequireListQueryCache = {}


local builtins = {
--- Used in case 'require( varName )' is found. Attempts to find a string value stored in 'varName'.
["libraryUtil"] = {
---@param content string    The content of the module to search in
link = "mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#libraryUtil",
---@param varName string
categories = {},
---@return string
},
local function substVarValue( content, varName )
["strict"] = {
    local res = content:match( varName .. '%s*=%s*(%b""%s-%.*)' ) or content:match( varName .. "%s*=%s*(%b''%s-%.*)" ) or ''
link = "mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#strict",
    if res:find( '^(["\'])[Mm]odule:[%S]+%1' ) and not res:find( '%.%.' ) and not res:find( '%%%a' ) then
categories = { "[[Category:Strict mode modules]]" },
        return mw.text.trim( res )
},
    else
}
        return ''
 
    end
-- Used in case 'require( varName )' is found. Attempts to find a string value stored in 'varName'.
local function substVarValue( moduleContent, varName )
local res = moduleContent:match( varName .. '%s*=%s*(%b""%s-%.*)' ) or moduleContent:match( varName .. "%s*=%s*(%b''%s-%.*)" ) or ''
if res:find( '^(["\'])[Mm]odule:[%S]+%1' ) and not res:find( '%.%.' ) and not res:find( '%%%a' ) then
return mw.text.trim( res )
else
return ''
end
end
end


local function extractModuleName( capture, moduleContent )
---@param capture string
capture = capture:gsub( '^%(%s*(.-)%s*%)$', '%1' )
---@param content string    The content of the module to search in
 
---@return string
if capture:find( '^(["\']).-%1$' ) then -- Check if it is already a pure string
local function extractModuleName( capture, content )
return capture
    capture = capture:gsub( '^%(%s*(.-)%s*%)$', '%1' )
elseif capture:find( '^[%a_][%w_]*$' ) then -- Check if if is a single variable
return substVarValue( moduleContent, capture )
end
 
return capture
end
 
local function formatPageName( str )
local name = mw.text.trim(str)
:gsub( '^([\'\"])(.-)%1$', '%2' ) -- Only remove quotes at start and end of string if both are the same type
:gsub( '_', ' ' )
:gsub( '^.', string.upper )
:gsub( '^([^:]-:)(.)', function(a,b) return a..string.upper(b) end )
 
return name
end
 
local function formatModuleName( str, allowBuiltins )
if allowBuiltins then
local name = mw.text.trim(str)
-- Only remove quotes at start and end of string if both are the same type
:gsub([[^(['"])(.-)%1$]], '%2')
 
if builtins[name] then
return name
end
end
 
local module = formatPageName( str )


if not string.find( module, '^[Mm]odule:' ) then
    if capture:find( '^(["\']).-%1$' ) then -- Check if it is already a pure string
module = 'Module:' .. module
        return capture
end
    elseif capture:find( '^[%a_][%w_]*$' ) then -- Check if if is a single variable
        return substVarValue( content, capture )
    end


return module
    return capture
end
end


local function dualGmatch( str, pat1, pat2 )
---@param str string
local f1 = string.gmatch( str, pat1 )
---@return string
if pat2 then
local function formatModuleName( str )
local f2 = string.gmatch( str, pat2 )
    return (str:gsub( '^([\'\"])(.-)%1$', function(_, x) return x end ) -- Only remove quotes at start and end of string if both are the same type
return function()
        :gsub( '_', ' ' )
return f1() or f2()
        :gsub( '^.', string.upper )
end
        :gsub( ':(.)', function(x) return ':'..x:upper() end ))
else
return f1
end
end
end


local function isDynamicPath( str )
--- Used in case a construct like 'require( "Module:wowee/" .. isTheBest )' is found.
return string.find( str, '%.%.' ) or string.find( str, '%%%a' )
--- Will return a list of pages which satisfy this pattern where 'isTheBest' can take any value.
end
---@param query string
 
---@return string[]    Sequence of strings
-- Used in case a construct like 'require( "Module:wowee/" .. isTheBest )' is found.
-- Will return a list of pages which satisfy this pattern where 'isTheBest' can take any value.
local function getDynamicRequireList( query )
local function getDynamicRequireList( query )
if query:find( '%.%.' ) then
    if query:find( '%.%.' ) then
query = mw.text.split( query, '..', true )
        query = mw.text.split( query, '..', true )
query = arr.map( query, function(x) return (x:match('^%s*[\'\"](.-)[\'\"]%s*$') or '%') end )
        query = enum.map( query, function(x) return mw.text.trim(x) end )
query = table.concat( query )
        query = enum.map( query, function(x) return (x:match('^[\'\"](.-)[\'\"]$') or '%') end )
else
        query = table.concat( query )
local _, _query = query:match( '(["\'])(.-)%1' )
    else
query = _query:gsub( '%%%a', '%%' ) -- Replace lua string.format specifiers with a dpl wildcard
        _, query = query:match( '(["\'])(.-)%1' )
end
        query = query:gsub( '%%%a', '%%' )
query = query:gsub( '^[Mm]odule:', '' )
    end
    query = query:gsub( '^[Mm]odule:', '' )


query = mw.language.getContentLanguage():ucfirst(query)
    if query:find( '^[Ee]xchange/' ) or query:find( '^[Dd]ata/' ) then
if query:find( '^Exchange/' ) or query:find( '^Data/' ) then
        return { 'Module:' .. query }  -- This format will later be used by formatDynamicQueryLink()
return { 'Module:' .. query }  -- This format will later be used by formatDynamicQueryLink()
    end
end


if dynamicRequireListQueryCache[ query ] then
    if dynamicRequireListQueryCache[ query ] then
return dynamicRequireListQueryCache[ query ]
        return dynamicRequireListQueryCache[ query ]
end
    end


local list = dpl.ask{
    local list = dpl.ask{
namespace = 'Module',
        namespace = 'Module',
titlematch = query,
        titlematch = query,
nottitlematch = '%/doc|'..query..'/%',
        nottitlematch = '%/doc|'..query..'/%',
distinct = 'strict',
        distinct = 'strict',
ordermethod = 'title',
        ignorecase = true,
count = MAX_DYNAMIC_REQUIRE_LIST_LENGTH + 1,
        ordermethod = 'title',
skipthispage = 'no',
        count = MAX_DYNAMIC_REQUIRE_LIST_LENGTH + 1,
allowcachedresults = true,
        skipthispage = 'no',
cacheperiod = 604800 -- One week
        allowcachedresults = true,
}
        cacheperiod = 604800 -- One week
    }


if #list > MAX_DYNAMIC_REQUIRE_LIST_LENGTH then
    if #list > MAX_DYNAMIC_REQUIRE_LIST_LENGTH then
list = { 'Module:' .. query }
        list = { 'Module:' .. query }
end
    end


dynamicRequireListQueryCache[ query ] = list
    dynamicRequireListQueryCache[ query ] = list


return list
    return list
end
end


--- Returns a list of modules loaded and required by module 'moduleName'.
--- Returns a list of modules loaded and required by module 'moduleName'.
local function getRequireLists( moduleContent )
---@param moduleName string
local requireList = arr{}
---@param searchForUsedTemplates boolean
local loadDataList = arr{}
---@return string[], string[], string[]
local loadJsonDataList = arr{}
local function getRequireList( moduleName, searchForUsedTemplates )
local dynamicRequirelist = arr{}
    local content = mw.title.new( moduleName ):getContent()
local dynamicLoadDataList = arr{}
    local requireList = {}
local dynamicLoadJsonDataList = arr{}
    local loadDataList = {}
local extraCategories = arr{}
    local usedTemplateList = {}
    local dynamicRequirelist = {}
    local dynamicLoadDataList = {}


local function getList( pat1, pat2, list, dynList )
    assert( content ~= nil, string.format( '%s does not exist', moduleName ) )
for match in dualGmatch( moduleContent, pat1, pat2 ) do
match = mw.text.trim( match )
local name = extractModuleName( match, moduleContent )


if isDynamicPath( name ) then
    content = content:gsub( '%-%-%[(=-)%[.-%]%1%]', '' ):gsub( '%-%-[^\n]*', '' ) -- Strip comments
dynList:insert( getDynamicRequireList( name ), true )
elseif name ~= '' then
name = formatModuleName( name, true )
table.insert( list, name )


if builtins[name] then
    local function dualGmatch( str, pat1, pat2 )
extraCategories = extraCategories:insert( builtins[name].categories, true )
        local f1 = string.gmatch( str, pat1 )
end
        local f2 = string.gmatch( str, pat2 )
end
        return function()
end
            return f1() or f2()
end
        end
    end


getList( 'require%s*(%b())', 'require%s*((["\'])%s*[Mm]odule:.-%2)', requireList, dynamicRequirelist )
    for match in dualGmatch( content, 'require%s*(%b())', 'require%s*((["\'])%s*[Mm]odule:.-%2)' ) do
getList( 'mw%.loadData%s*(%b())', 'mw%.loadData%s*((["\'])%s*[Mm]odule:.-%2)', loadDataList, dynamicLoadDataList )
        match = mw.text.trim( match )
getList( 'mw%.loadJsonData%s*(%b())', 'mw%.loadJsonData%s*((["\'])%s*[Mm]odule:.-%2)', loadJsonDataList, dynamicLoadJsonDataList )
        match = extractModuleName( match, content )
getList( 'pcall%s*%(%s*require%s*,([^%),]+)', nil, requireList, dynamicRequirelist )
getList( 'pcall%s*%(%s*mw%.loadData%s*,([^%),]+)', nil, loadDataList, dynamicLoadDataList )
getList( 'pcall%s*%(%s*mw%.loadJsonData%s*,([^%),]+)', nil, loadJsonDataList, dynamicLoadJsonDataList )


requireList = requireList .. dynamicRequirelist
        if match:find( '%.%.' ) or match:find( '%%%a' ) then
requireList = requireList:unique()
            for _, x in ipairs( getDynamicRequireList( match ) ) do
loadDataList = loadDataList .. dynamicLoadDataList .. loadJsonDataList .. dynamicLoadJsonDataList
                table.insert( dynamicRequirelist, x )
loadDataList = loadDataList:unique()
            end
extraCategories = extraCategories:unique()
        elseif match ~= '' then
table.sort( requireList )
            match = formatModuleName( match )
table.sort( loadDataList )
table.sort( extraCategories )


return {
            if match == 'LibraryUtil' then
require = requireList,
                match = 'Module:LibraryUtil'
loadData = loadDataList,
            end
extraCategories = extraCategories,
}
end


local function getUsedTemplatesList( moduleContent )
            table.insert( requireList, match )
local usedTemplateList = arr{}
        end
    end


for preprocess in string.gmatch( moduleContent, ':preprocess%s*(%b())' ) do
    for match in dualGmatch( content, 'mw%.loadData%s*(%b())', 'mw%.loadData%s*((["\'])%s*[Mm]odule:.-%2)' ) do
local function recursiveGMatch( str, pat )
        match = mw.text.trim( match )
local list = {}
        match = extractModuleName( match, content )
local i = 0
repeat
for match in string.gmatch( list[i] or str, pat ) do
table.insert( list, match )
end
i = i + 1
until i > #list or i > 100


i = 0
        if match:find( '%.%.' ) or match:find( '%%%a' ) then
return function()
            for _, x in ipairs( getDynamicRequireList( match ) ) do
i = i + 1
                table.insert( dynamicLoadDataList, x )
return list[i]
            end
end
        elseif match ~= '' then
end
            match = formatModuleName( match )
            table.insert( loadDataList, match )
        end
    end


for template in recursiveGMatch( preprocess, '{(%b{})}' ) do
    for func, match in string.gmatch( content, 'pcall%s*%(([^,]+),([^%),]+)' ) do
local name = string.match( template, '{(.-)[|{}]' )
        func = mw.text.trim( func )
if name ~= '' then
        match = mw.text.trim( match )
if name:find( ':' ) then
local ns = name:match( '^(.-):' )
if arr.contains( {'', 'template', 'calculator', 'user'}, ns:lower() ) then
table.insert( usedTemplateList, name )
elseif ns == ns:upper() then
table.insert( usedTemplateList, ns ) -- Probably a magic word
end
else
if name:match( '^%u+$' ) or name == '!' then
table.insert( usedTemplateList, name ) -- Probably a magic word
else
table.insert( usedTemplateList, 'Template:'..name )
end
end
end
end
end


usedTemplateList = usedTemplateList:unique()
        if func == 'require' then
table.sort( usedTemplateList )
            for _, x in ipairs( getDynamicRequireList( match ) ) do
                table.insert( dynamicRequirelist, x )
            end
        elseif func == 'mw.loadData' then
            for _, x in ipairs( getDynamicRequireList( match ) ) do
                table.insert( dynamicLoadDataList, x )
            end
        end
    end


return usedTemplateList
    if searchForUsedTemplates then
end
        for preprocess in string.gmatch( content, ':preprocess%s*(%b())' ) do
            local function recursiveGMatch( str, pat )
                local list = {}
                local i = 0
                repeat
                    for match in string.gmatch( list[i] or str, pat ) do
                        table.insert( list, match )
                    end
                    i =  i + 1
                until i > #list or i > 100


-- Returns a list with module and function names used in all '{{#Invoke:moduleName|funcName}}' found on page 'templateName'.
                i = 0
local function getInvokeCallList( pageName )
                return function()
local pageContent = mw.title.new( pageName ):getContent()
                    i = i + 1
local invokeList = {}
                    return list[i]
                end
            end


assert( pageContent, string.format( 'Failed to retrieve text content of page "%s"', pageName ) )
            for template in recursiveGMatch( preprocess, '{(%b{})}' ) do
                local name = string.match( template, '{(.-)[|{}]' )
                if name ~= '' then
                    if name:find( ':' ) then
                        local ns = name:match( '^(.-):' )
                        if enum.contains( {'', 'template', 'calculator', 'user'}, ns:lower() ) then
                            table.insert( usedTemplateList, name )
                        elseif ns == ns:upper() then
                            table.insert( usedTemplateList, ns ) -- Probably a magic word
                        end
                    else
                        if name:match( '^%u+$' ) or name == '!' then
                            table.insert( usedTemplateList, name ) -- Probably a magic word
                        else
                            table.insert( usedTemplateList, 'Template:'..name )
                        end
                    end
                end
            end
        end
    end


for moduleName, funcName in string.gmatch( pageContent, '{{[{|safeubt:}]-#[Ii]nvoke:([^|]+)|([^}|]+)[^}]*}}' ) do
    dynamicRequirelist = enum.reject( dynamicRequirelist, function(x) return (enum.contains(requireList, x) or enum.contains(loadDataList, x)) end )
moduleName = formatModuleName( moduleName )
    dynamicLoadDataList = enum.reject( dynamicLoadDataList, function(x) return (enum.contains(requireList, x) or enum.contains(loadDataList, x)) end )
funcName = mw.text.trim( funcName )
    requireList = enum.insert( requireList, dynamicRequirelist )
if string.find( funcName, '^{{{' ) then
    requireList = enum.unique( requireList )
funcName = funcName .. '}}}'
    loadDataList = enum.insert( loadDataList, dynamicLoadDataList )
end
    loadDataList = enum.unique( loadDataList )
table.insert( invokeList, {moduleName=moduleName, funcName=funcName} )
    usedTemplateList = enum.unique( usedTemplateList )
end
    table.sort( requireList )
    table.sort( loadDataList )
    table.sort( usedTemplateList )


-- For form calcs invoking the module directly
    return requireList, loadDataList, usedTemplateList
for config in dualGmatch( pageContent, '<[pd][ri][ev]%s+class%s*=%s*["\']jcConfig["\'](.-)</[pd][ri][ev]>', '{{[Ff]orm calculator%s*|(.+)}}' ) do
local moduleName = string.match( config, 'module%s*=%s*(.-)[\n|]' )
if param.has_content( moduleName ) then
moduleName = formatModuleName( moduleName )
local funcName = string.match( config, 'modulefunc%s*=%s*(.-)[\n|]' ) or 'main'
table.insert( invokeList, {moduleName=moduleName, funcName=funcName} )
end
end
 
invokeList = arr.unique( invokeList, function(x) return x.moduleName..x.funcName end )
table.sort( invokeList, function(x, y) return x.moduleName..x.funcName < y.moduleName..y.funcName end )
 
return invokeList
end
end


local function getInvokedByList( moduleName )
--- Returns a list with module and function names used in all '{{#Invoke:moduleName|funcName}}' found on page 'templateName'.
local whatTemplatesLinkHere = dpl.ask( {
---@param templateName string
namespace = 'Template|Calculator',
---@return table<string, string>[]
linksto = moduleName,
local function getInvokeCallList( templateName )
distinct = 'strict',
    local content = mw.title.new( templateName ):getContent()
ordermethod = 'title',
    local invokeList = {}
allowcachedresults = true,
cacheperiod = 604800 -- One week
} )
 
local function lcfirst( str )
return string.gsub( str, '^[Mm]odule:.', string.lower )
end


local invokedByList = {}
    assert( content ~= nil, string.format( '%s does not exist', templateName ) )


for _, templateName in ipairs( whatTemplatesLinkHere ) do
    for moduleName, funcName in string.gmatch( content, '{{[{|safeubt:}]-#[Ii]nvoke:([^|]+)|([^}|]+)[^}]*}}' ) do
local invokeList = getInvokeCallList( templateName )
        moduleName = string.format( 'Module:%s', mw.text.trim( moduleName ) )
        moduleName = formatModuleName( moduleName )
        funcName = mw.text.trim( funcName )
        table.insert( invokeList, {moduleName=moduleName, funcName=funcName} )
    end


for _, invokeData in ipairs( invokeList ) do
    invokeList = enum.unique( invokeList, function(x) return x.moduleName..x.funcName end )
if lcfirst( invokeData.moduleName ) == lcfirst( moduleName ) then
    table.sort( invokeList, function(x, y) return x.moduleName..x.funcName < y.moduleName..y.funcName end )
table.insert( invokedByList, { templateName=templateName, funcName=invokeData.funcName } )
end
end
end


return invokedByList
    return invokeList
end
end


local function messageBoxUnused()
---@param pageName string
local html = mw.html.create( 'table' ):addClass( 'messagebox obsolete plainlinks' )
---@param addCategories boolean
html:tag( 'td' )
---@return string
:attr( 'width', '40xp' )
local function messageBoxUnused( pageName, addCategories )
:wikitext( '[[File:Willow logs (historical).png|center|30px|link=]]' )
    local html = mw.html.create( 'table' ):addClass( 'messagebox obsolete plainlinks' )
:done()
    html:tag( 'td' )
:tag( 'td' )
        :attr( 'width', '40xp' )
:wikitext( "'''This module is unused.'''" )
        :wikitext( '[[File:Old boot detail.png|center|30px|link=]]' )
:tag( 'div' )
    :done()
:css{ ['font-size']='0.85em', ['line-height']='1.45em' }
    :tag( 'td' )
:wikitext( 'This module is neither invoked by a template nor required/loaded by another module. If this is in error, make sure to add <code>{{[[Template:Documentation|Documentation]]}}</code>/<code>{{[[Template:No documentation|No&nbsp;documentation]]}}</code> to the calling template\'s or parent\'s module documentation.' )
        :wikitext( "'''This module is unused.'''" )
:done()
        :tag( 'div' )
:done()
            :css{ ['font-size']='0.85em', ['line-height']='1.45em' }
            :wikitext( string.format( 'This module is neither invoked by a template nor required/loaded by another module. If this is in error, make sure to add <code>{{[[Template:Documentation|Documentation]]}}</code>/<code>{{[[Template:No documentation|No&nbsp;documentation]]}}</code> to the calling template\'s or parent\'s module documentation.', pageName ) )
            :wikitext( addCategories and '[[Category:Unused modules]]' or '' )
        :done()
    :done()


return tostring( html )
    return tostring( html )
end
end


local function collapseList( list, id, listType )
local function collapseList( list, id, listType )
local text = string.format( '%d %s', #list, listType )
    local text = string.format( '%d %s', #list, listType )
local button = tooltip._span{ name=id, alt=text }
    local button = tooltip._span{ name=id, alt=text }
list = arr.map( list, function(x) return '\n# '..x end )
    list = enum.map( list, function(x) return '\n# '..x end )
local content = tooltip._div{ name=id, content='\n'..table.concat( list )..'\n\n' }
    local content = tooltip._div{ name=id, content='\n'..table.concat( list )..'\n\n' }


return { tostring( button ) .. tostring( content ) }
    return { tostring( button ) .. tostring( content ) }
end
end


-- Creates a link to [[Special:Search]] showing all pages found by getDynamicRequireList() in case it found more than MAX_DYNAMIC_REQUIRE_LIST_LENGTH pages.
--- Creates a link to [[Special:Search]] showing all pages found by getDynamicRequireList() in case it found more than MAX_DYNAMIC_REQUIRE_LIST_LENGTH pages.
-- Input query uses DPL % wildcards like 'Module:Wowee/%' or 'Module:Wowee/%/data'
---@param query string      @This will be in a format like 'Module:Wowee/%' or 'Module:Wowee/%/data'
---@return string
local function formatDynamicQueryLink( query )
local function formatDynamicQueryLink( query )
local prefix = query:match( '^([^/]+)' )
    local prefix = query:match( '^([^/]+)' )
local linkText = query:gsub( '%%', '&lt; ... &gt;' )
    local linkText = query:gsub( '%%', '&lt; ... &gt;' )


query = query:gsub( '^Module:',  '' )
    query = query:gsub( '^Module:',  '' )


query = query:gsub( '([^/]+)/?', function ( match )
    query = query:gsub( '([^/]+)/?', function ( match )
if match == '%' then
        if match == '%' then
return '\\/[^\\/]+'
            return '\\/[^\\/]+'
else
        else
return '\\/"' .. match .. '"'
            return '\\/"' .. match .. '"'
end
        end
end )
    end )


query = query:gsub( '^\\/', '' )
    query = query:gsub( '^\\/', '' )


query = string.format(
    query = string.format(
'intitle:/%s%s/i -intitle:/%s\\/""/i -intitle:doc prefix:"%s"',
        'intitle:/%s%s/i -intitle:/%s\\/""/i -intitle:doc prefix:"%s"',
query,
        query,
query:find( '"$' ) and '' or '""',
        query:find( '"$' ) and '' or '""',
query,
        query,
prefix
        prefix
)
    )


return string.format( '<span class="plainlinks">[%s %s]</span>', tostring( mw.uri.fullUrl( 'Special:Search', { search = query } ) ), linkText )
    return string.format( '<span class="plainlinks">[%s %s]</span>', tostring( mw.uri.fullUrl( 'Special:Search', { search = query } ) ), linkText )
end
end


local function formatModuleLinks( pages )
---@param templateName string
local links = arr{}
---@param addCategories boolean
---@param invokeList table<string, string>[]    @This is the list returned by getInvokeCallList()
---@return string
local function formatInvokeCallList( templateName, addCategories, invokeList )
    local category = addCategories and '[[Category:Lua-based templates]]' or ''
    local res = {}
 
    for _, item in ipairs( invokeList ) do
        table.insert( res, string.format(
            "<div class=\"seealso\">'''%s''' invokes function '''%s''' in [[%s]] using [[RuneScape:Lua|Lua]].</div>",
            templateName,
            item.funcName,
            item.moduleName
        ) )
    end


for _, moduleName in ipairs(pages) do
    if #invokeList > 0 then
if moduleName:find( '%%' ) then
        table.insert( res, category )
links:insert( formatDynamicQueryLink( moduleName ) )
    end
elseif builtins[moduleName] then
links:insert( '[[' .. builtins[moduleName].link .. '|' .. moduleName .. ']]' )
else
links:insert( '[[' .. moduleName .. ']]' )
end
end


return links
    return table.concat( res )
end
end


local function formatTemplateLinks( pages )
---@param moduleName string
local links = arr{}
---@param addCategories boolean
---@param whatLinksHere string    @A list generated by a dpl of pages in the Template or Calculator namespace which link to moduleName.
---@return string
local function formatInvokedByList( moduleName, addCategories, whatLinksHere )
    local templateData = enum.map( whatLinksHere, function(x) return {templateName=x, invokeList=getInvokeCallList(x)} end )
    templateData = enum.filter( templateData, function(x)
        return enum.any( x.invokeList, function(y)
            return y.moduleName:lower() == moduleName:lower()
        end )
    end )
 
    local invokedByList = {}


for _, templateName in ipairs(pages) do
    for _, template in ipairs( templateData ) do
if string.find( templateName, ':' ) then -- Real templates are prefixed by a namespace, magic words are not
        for _, invoke in ipairs( template.invokeList ) do
links:insert( '[['..templateName..']]' )
            table.insert( invokedByList, string.format( "function '''%s''' is invoked by [[%s]]", invoke.funcName, template.templateName ) )
else
        end
links:insert( "'''&#123;&#123;"..templateName.."&#125;&#125;'''" ) -- Magic words don't have a page so make them bold instead
    end
end
end


return links
    table.sort( invokedByList)
end
 
    local res = {}


local function formatInvokeCallList( templateName, invokeList )
    if #invokedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
local res = {}
        table.insert( res, string.format(
            "<div class=\"seealso\">'''%s''' is invoked by %s.</div>",
            moduleName,
            collapseList( invokedByList, 'invokedBy', 'templates' )[1]
        ) )
    else
        for _, item in ipairs( invokedByList ) do
            table.insert( res, string.format(
                "<div class=\"seealso\">'''%s's''' %s.</div>",
                moduleName,
                item
            ) )
        end
    end


for _, item in ipairs( invokeList ) do
    if #templateData > 0 then
table.insert( res, string.format(
        moduleIsUsed = true
"<div class='seealso'>'''%s''' invokes function '''%s''' in [[%s]] using [[RuneScape:Lua|Lua]].</div>",
        table.insert( res, (addCategories and '[[Category:Template invoked modules]]' or '') )
templateName,
    end
item.funcName,
item.moduleName
) )
end


return table.concat( res )
    return table.concat( res )
end
end


local function formatInvokedByList( moduleName, invokedByList )
---@param moduleName string
for i, invoke in ipairs( invokedByList ) do
---@param addCategories boolean
invokedByList[i] = string.format( "function '''%s''' is invoked by [[%s]]", invoke.funcName, invoke.templateName )
---@param whatLinksHere string      @A list generated by a dpl of pages in the Module namespace which link to moduleName.
end
---@return string
local function formatRequiredByList( moduleName, addCategories, whatLinksHere )
    local childModuleData = enum.map( whatLinksHere, function ( title )
        local requireList, loadDataList = getRequireList( title )
        return {name=title, requireList=requireList, loadDataList=loadDataList}
    end )


table.sort( invokedByList)
    local requiredByList = enum.map( childModuleData, function ( item )
        if enum.any( item.requireList, function(x) return x:lower()==moduleName:lower() end ) then
            if item.name:find( '%%' ) then
                return formatDynamicQueryLink( item.name )
            else
                return '[[' .. item.name .. ']]'
            end
        end
    end )


local res = {}
    local loadedByList = enum.map( childModuleData, function ( item )
        if enum.any( item.loadDataList, function(x) return x:lower()==moduleName:lower() end ) then
            if item.name:find( '%%' ) then
                return formatDynamicQueryLink( item.name )
            else
                return '[[' .. item.name .. ']]'
            end
        end
    end )


if #invokedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
    if #requiredByList > 0 or #loadedByList > 0 then
table.insert( res, string.format(
        moduleIsUsed  = true
"<div class='seealso'>'''%s''' is invoked by %s.</div>",
    end
moduleName,
collapseList( invokedByList, 'invokedBy', 'templates' )[1]
) )
else
for _, item in ipairs( invokedByList ) do
table.insert( res, string.format(
"<div class='seealso'>'''%s's''' %s.</div>",
moduleName,
item
) )
end
end


return table.concat( res )
    if #requiredByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
end
        requiredByList = collapseList( requiredByList, 'requiredBy', 'modules' )
    end


local function formatRequiredByList( moduleName, requiredByLists )
    if #loadedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
local requiredByList = formatModuleLinks( requiredByLists.require )
        loadedByList = collapseList( loadedByList, 'loadedBy', 'modules' )
local loadedByList = formatModuleLinks( requiredByLists.loadData )
    end


if #requiredByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
    local res = {}
requiredByList = collapseList( requiredByList, 'requiredBy', 'modules' )
end


if #loadedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
    for _, requiredByModuleName in ipairs( requiredByList ) do
loadedByList = collapseList( loadedByList, 'loadedBy', 'modules' )
        table.insert( res, string.format(
end
            "<div class=\"seealso\">'''%s''' is required by %s.</div>",
            moduleName,
            requiredByModuleName
        ) )
    end


local res = {}
    if #requiredByList > 0 then
        table.insert( res, (addCategories and '[[Category:Modules required by modules]]' or '') )
    end


for _, requiredByModuleName in ipairs( requiredByList ) do
    for _, loadedByModuleName in ipairs( loadedByList ) do
table.insert( res, string.format(
        table.insert( res, string.format(
"<div class='seealso'>'''%s''' is required by %s.</div>",
            "<div class=\"seealso\">'''%s''' is loaded by %s.</div>",
moduleName,
            moduleName,
requiredByModuleName
            loadedByModuleName
) )
        ) )
end
    end


for _, loadedByModuleName in ipairs( loadedByList ) do
    if #loadedByList > 0 then
table.insert( res, string.format(
        table.insert( res, (addCategories and '[[Category:Module data]]' or '') )
"<div class='seealso'>'''%s''' is loaded by %s.</div>",
    end
moduleName,
loadedByModuleName
) )
end


return table.concat( res )
    return table.concat( res )
end
end


local function formatImportList( currentPageName, moduleList, id, message )
local function formatRequireList( currentPageName, addCategories, requireList )
moduleList = formatModuleLinks( moduleList )
    local res = {}


if #moduleList > COLLAPSE_LIST_LENGTH_THRESHOLD then
    if #requireList > COLLAPSE_LIST_LENGTH_THRESHOLD then
moduleList = collapseList( moduleList, id, 'modules' )
        requireList = collapseList( requireList, 'require', 'modules' )
end
    end


local res = arr.map( moduleList, function( moduleName )
    for _, requiredModuleName in ipairs( requireList ) do
return '<div class="seealso">' .. string.format( message, currentPageName, moduleName ) .. '</div>'
        table.insert( res, string.format(
end )
            "<div class=\"seealso\">'''%s''' requires %s.</div>",
            currentPageName,
            requiredModuleName
        ) )
    end


return table.concat( res )
    if #requireList > 0 then
        table.insert( res, (addCategories and '[[Category:Modules requiring modules]]' or '') )
    end
 
    return table.concat( res )
end
end


local function formatUsedTemplatesList( currentPageName, usedTemplateList )
local function formatLoadDataList( currentPageName, addCategories, loadDataList )
usedTemplateList = formatTemplateLinks( usedTemplateList )
    local res = {}
local res = {}


if #usedTemplateList > COLLAPSE_LIST_LENGTH_THRESHOLD then
    if #loadDataList > COLLAPSE_LIST_LENGTH_THRESHOLD then
usedTemplateList = collapseList( usedTemplateList, 'usedTemplates', 'templates' )
        loadDataList = collapseList( loadDataList, 'loadData', 'modules' )
end
    end


for _, templateName in ipairs( usedTemplateList ) do
    for _, loadedModuleName in ipairs( loadDataList ) do
table.insert( res, string.format(
        table.insert( res, string.format(
"<div class='seealso'>'''%s''' transcludes %s using <samp>frame:preprocess()</samp>.</div>",
            "<div class=\"seealso\">'''%s''' loads data from %s.</div>",
currentPageName,
            currentPageName,
templateName
            loadedModuleName
) )
        ) )
end
    end


return table.concat( res )
    if #loadDataList > 0 then
end
        table.insert( res, (addCategories and '[[Category:Modules using data]]' or '') )
    end


local function setBucketFields( requireLists )
    return table.concat( res )
if mw.title.getCurrentTitle().subpageText ~= 'doc' and (#requireLists.require > 0 or #requireLists.loadData > 0) then
bucket( 'dependency_list' ).put{
require = requireLists.require,
load_data = requireLists.loadData
}
end
end
end


local function getRequiredByLists( currentPageName )
local function formatUsedTemplatesList( currentPageName, addCategories, usedTemplateList )
local requiredByListRaw = bucket( 'dependency_list' ).select( 'page_name' ).where( 'require', currentPageName ).run()
    local res = {}
local loadedByListRaw = bucket( 'dependency_list' ).select( 'page_name' ).where( 'load_data', currentPageName ).run()
local requiredByList = {}
local loadedByList = {}


for _, bucketItem in ipairs( requiredByListRaw ) do
    if #usedTemplateList > COLLAPSE_LIST_LENGTH_THRESHOLD then
table.insert( requiredByList, bucketItem.page_name )
        usedTemplateList = collapseList( usedTemplateList, 'usedTemplates', 'templates' )
end
    end
for _, bucketItem in ipairs( loadedByListRaw ) do
table.insert( loadedByList, bucketItem.page_name )
end


requiredByList = arr.unique( requiredByList )
    for _, templateName in ipairs( usedTemplateList ) do
loadedByList = arr.unique( loadedByList )
        table.insert( res, string.format(
table.sort( requiredByList )
            "<div class=\"seealso\">'''%s''' transcludes %s using <samp>frame:preprocess()</samp>.</div>",
table.sort( loadedByList )
            currentPageName,
            templateName
        ) )
    end


return {
    return table.concat( res )
require = requiredByList,
loadData = loadedByList
}
end
end


local function templateDependencyList( currentPageName, addCategories )
function p.main( frame )
local invokeList = getInvokeCallList( currentPageName )
    local args = frame:getParent().args
local res = formatInvokeCallList( currentPageName, invokeList )
    return p._main( args[1], args.category, args.isUsed )
 
if addCategories and #invokeList > 0 then
res = res .. '[[Category:Lua-based templates]]'
end
 
return res
end
end


local function moduleDependencyList( currentPageName, addCategories, isUsed )
---@param currentPageName string|nil
local moduleContent = mw.title.new( currentPageName ):getContent()
---@param addCategories boolean|string|nil
assert( moduleContent, string.format( 'Failed to retrieve text content of page "%s"', currentPageName ) )
---@return string
moduleContent = moduleContent:gsub( '%-%-%[(=-)%[.-%]%1%]', '' ):gsub( '%-%-[^\n]*', '' ) -- Strip comments
function p._main( currentPageName, addCategories, isUsed )
    libraryUtil.checkType( 'Module:RequireList._main', 1, currentPageName, 'string', true )
    libraryUtil.checkTypeMulti( 'Module:RequireList._main', 2, addCategories, {'boolean', 'string', 'nil'} )
    libraryUtil.checkTypeMulti( 'Module:RequireList._main', 3, isUsed, {'boolean', 'string', 'nil'} )


local requireLists = getRequireLists( moduleContent )
    local title = mw.title.getCurrentTitle()
local usedTemplateList = getUsedTemplatesList( moduleContent )
local requiredByLists = getRequiredByLists( currentPageName )
local invokedByList = getInvokedByList( currentPageName )


setBucketFields( requireLists )
    -- Leave early if not in module, template or calculator namespace or if module is part of exchange groups
    if param.is_empty( currentPageName ) and (
        ( not enum.contains( {'Module', 'Template', 'Calculator'}, title.nsText ) ) or
        ( title.nsText == 'Module' and ( enum.contains( {'Exchange', 'Exchange historical'}, title.text:match( '^(.-)/' ) ) ) )
    ) then
        return ''
    end


local res = arr{}
    currentPageName = param.default_to( currentPageName, title.fullText )
    currentPageName = string.gsub( currentPageName, '/[Dd]oc$', '' )
    currentPageName = formatModuleName( currentPageName )
    addCategories = yn( param.default_to( addCategories, title.subpageText~='doc' ) )
    moduleIsUsed = yn( param.default_to( isUsed, false ) )
   
    if title.text:lower():find( 'sandbox' ) then
    moduleIsUsed = true -- Don't show sandbox modules as unused
    end


res:insert( formatInvokedByList( currentPageName, invokedByList ) )
    if currentPageName:find( '^Template:' ) or currentPageName:find( '^Calculator:' ) then
res:insert( formatImportList( currentPageName, requireLists.require, 'require', "'''%s''' requires %s." ) )
        local invokeList = getInvokeCallList( currentPageName )
res:insert( formatImportList( currentPageName, requireLists.loadData, 'loadData', "'''%s''' loads data from %s." ) )
        return formatInvokeCallList( currentPageName, addCategories, invokeList )
res:insert( formatUsedTemplatesList( currentPageName, usedTemplateList ) )
    end
res:insert( formatRequiredByList( currentPageName, requiredByLists ) )


if addCategories then
    local whatTemplatesLinkHere, whatModulesLinkHere = dpl.ask( {
res:insert( requireLists.extraCategories, true )
        namespace = 'Template|Calculator',
        linksto = currentPageName,
        distinct = 'strict',
        ignorecase = true,
        ordermethod = 'title',
        allowcachedresults = true,
        cacheperiod = 604800 -- One week
    }, {
        namespace = 'Module',
        linksto = currentPageName,
        nottitlematch = '%/doc|Exchange/%|Exchange historical/%|' .. currentPageName:gsub( 'Module:', '' ),
        distinct = 'strict',
        ignorecase = true,
        ordermethod = 'title',
        allowcachedresults = true,
        cacheperiod = 604800 -- One week
    } )


if #requireLists.require > 0 then
    local requireList, loadDataList, usedTemplateList = getRequireList( currentPageName, true )
res:insert( '[[Category:Modules requiring modules]]')
end
if #requireLists.loadData > 0 then
res:insert( '[[Category:Modules using data]]')
end
if #requiredByLists.require > 0 then
res:insert( '[[Category:Modules required by modules]]')
end
if #requiredByLists.loadData > 0 then
res:insert( '[[Category:Module data]]')
end
if #invokedByList > 0 then
res:insert( '[[Category:Template invoked modules]]')
end
end


if
    requireList = enum.map( requireList, function ( moduleName )
not (
        if moduleName:find( '%%' ) then
yn( isUsed )
            return formatDynamicQueryLink( moduleName )
or currentPageName:lower():find( 'sandbox' )
        else
or #requiredByLists.require > 0
            return '[[' .. moduleName .. ']]'
or #requiredByLists.loadData > 0
        end
or #invokedByList > 0
    end )
)
then
table.insert( res, 1, messageBoxUnused() )
 
if addCategories then
res:insert( '[[Category:Unused modules]]')
end
end
 
return table.concat( res )
end
 
function p.main( frame )
local args = frame:getParent().args
return p._main( args[1], args.category, args.isUsed )
end
 
function p._main( currentPageName, addCategories, isUsed )
libraryUtil.checkType( 'Module:RequireList._main', 1, currentPageName, 'string', true )
libraryUtil.checkTypeMulti( 'Module:RequireList._main', 2, addCategories, {'boolean', 'string', 'nil'} )
libraryUtil.checkTypeMulti( 'Module:RequireList._main', 3, isUsed, {'boolean', 'string', 'nil'} )


local title = mw.title.getCurrentTitle()
    loadDataList = enum.map( loadDataList, function ( moduleName )
        if moduleName:find( '%%' ) then
            return formatDynamicQueryLink( moduleName )
        else
            return '[[' .. moduleName .. ']]'
        end
    end )


-- Leave early if not in module, template or calculator namespace or if module is part of exchange or data groups
    usedTemplateList = enum.map( usedTemplateList, function( templateName )
if param.is_empty( currentPageName ) and (
        if string.find( templateName, ':' ) then -- Real templates are prefixed by a namespace, magic words are not
( not arr.contains( {'Module', 'Template', 'Calculator'}, title.nsText ) ) or
            return '[['..templateName..']]'
( title.nsText == 'Module' and ( arr.contains( {'Exchange', 'Exchange historical', 'Data'}, title.text:match( '^(.-)/' ) ) ) )
        else
) then
            return "'''&#123;&#123;"..templateName.."&#125;&#125;'''" -- Magic words don't have a page so make them bold instead
return ''
        end
end
    end )


currentPageName = param.default_to( currentPageName, title.fullText )
    local res = {}
currentPageName = string.gsub( currentPageName, '/[Dd]oc$', '' )
currentPageName = formatPageName( currentPageName )


if (addCategories == nil) then
    table.insert( res, formatInvokedByList( currentPageName, addCategories, whatTemplatesLinkHere ) )
addCategories = title.subpageText~='doc'
    table.insert( res, formatRequireList( currentPageName, addCategories, requireList ) )
end
    table.insert( res, formatLoadDataList( currentPageName, addCategories, loadDataList ) )
addCategories = yn(addCategories)
    table.insert( res, formatUsedTemplatesList( currentPageName, addCategories, usedTemplateList ) )
    table.insert( res, formatRequiredByList( currentPageName, addCategories, whatModulesLinkHere ) )


if currentPageName:find( '^Template:' ) or currentPageName:find( '^Calculator:' ) then
    if not moduleIsUsed then
return templateDependencyList( currentPageName, addCategories )
        table.insert( res, 1, messageBoxUnused( currentPageName:gsub( 'Module:', '' ), addCategories ) )
end
    end


return moduleDependencyList( currentPageName, addCategories, isUsed )
    return table.concat( res )
end
end


return p
return p
-- </nowiki>
Please note that all contributions to The Deadlock Wiki are considered to be released under the Creative Commons Attribution-NonCommercial-ShareAlike (see Deadlock:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)
Preview page with this template

Page included on this page:

Retrieved from "https://deadlock.wiki/Module:DependencyList"