@@ Line 1: / Line 1: @@
+-- <nowiki>
+local p = {}
+local libraryUtil = require( 'libraryUtil' )
+local enum = require( 'Module:Enum' )
+local yn = require( 'Module:Yesno' )
+local param = require( 'Module:Paramtest' )
+local dpl = require( 'Module:DPLlua' )
+local tooltip = require( 'Module:Tooltip' )
+local moduleIsUsed = false
+local COLLAPSE_LIST_LENGTH_THRESHOLD = 5
+local MAX_DYNAMIC_REQUIRE_LIST_LENGTH = 30
+local dynamicRequireListQueryCache = {}
+--- Used in case 'require( varName )' is found. Attempts to find a string value stored in 'varName'.
+---@param content string    The content of the module to search in
+---@param varName string
+---@return string
+local function substVarValue( content, varName )
+    local res = content:match( varName .. '%s*=%s*(%b""%s-%.*)' ) or content: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
+---@param capture string
+---@param content string    The content of the module to search in
+---@return string
+local function extractModuleName( capture, content )
+    capture = capture:gsub( '^%(%s*(.-)%s*%)$', '%1' )
+    if capture:find( '^(["\']).-%1$' ) then -- Check if it is already a pure string
+        return capture
+    elseif capture:find( '^[%a_][%w_]*$' ) then -- Check if if is a single variable
+        return substVarValue( content, capture )
+    end
+    return capture
+end
+---@param str string
+---@return string
+local function formatModuleName( str )
+    return (str:gsub( '^([\'\"])(.-)%1$', function(_, x) return x end ) -- Only remove quotes at start and end of string if both are the same type
+        :gsub( '_', ' ' )
+        :gsub( '^.', string.upper )
+        :gsub( ':(.)', function(x) return ':'..x:upper() end ))
+end
+--- 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.
+---@param query string
+---@return string[]     Sequence of strings
+local function getDynamicRequireList( query )
+    if query:find( '%.%.' ) then
+        query = mw.text.split( query, '..', true )
+        query = enum.map( query, function(x) return mw.text.trim(x) end )
+        query = enum.map( query, function(x) return (x:match('^[\'\"](.-)[\'\"]$') or '%') end )
+        query = table.concat( query )
+    else
+        _, query = query:match( '(["\'])(.-)%1' )
+        query = query:gsub( '%%%a', '%%' )
+    end
+    query = query:gsub( '^[Mm]odule:', '' )
+    if query:find( '^[Ee]xchange/' ) or query:find( '^[Dd]ata/' ) then
+        return { 'Module:' .. query }   -- This format will later be used by formatDynamicQueryLink()
+    end
+    if dynamicRequireListQueryCache[ query ] then
+        return dynamicRequireListQueryCache[ query ]
+    end
+    local list = dpl.ask{
+        namespace = 'Module',
+        titlematch = query,
+        nottitlematch = '%/doc|'..query..'/%',
+        distinct = 'strict',
+        ignorecase = true,
+        ordermethod = 'title',
+        count = MAX_DYNAMIC_REQUIRE_LIST_LENGTH + 1,
+        skipthispage = 'no',
+        allowcachedresults = true,
+        cacheperiod = 604800 -- One week
+    }
+    if #list > MAX_DYNAMIC_REQUIRE_LIST_LENGTH then
+        list = { 'Module:' .. query }
+    end
+    dynamicRequireListQueryCache[ query ] = list
+    return list
+end
+--- Returns a list of modules loaded and required by module 'moduleName'.
+---@param moduleName string
+---@param searchForUsedTemplates boolean
+---@return string[], string[], string[]
+local function getRequireList( moduleName, searchForUsedTemplates )
+    local content = mw.title.new( moduleName ):getContent()
+    local requireList = {}
+    local loadDataList = {}
+    local usedTemplateList = {}
+    local dynamicRequirelist = {}
+    local dynamicLoadDataList = {}
+    assert( param.has_content( content ), string.format( '%s does not exist', moduleName ) )
+    content = content:gsub( '%-%-%[(=-)%[.-%]%1%]', '' ):gsub( '%-%-[^\n]*', '' ) -- Strip comments
+    local function dualGmatch( str, pat1, pat2 )
+        local f1 = string.gmatch( str, pat1 )
+        local f2 = string.gmatch( str, pat2 )
+        return function()
+            return f1() or f2()
+        end
+    end
+    for match in dualGmatch( content, 'require%s*(%b())', 'require%s*((["\'])%s*[Mm]odule:.-%2)' ) do
+        match = mw.text.trim( match )
+        match = extractModuleName( match, content )
+        if match:find( '%.%.' ) or match:find( '%%%a' ) then
+            for _, x in ipairs( getDynamicRequireList( match ) ) do
+                table.insert( dynamicRequirelist, x )
+            end
+        elseif match ~= '' then
+            match = formatModuleName( match )
+            if match == 'LibraryUtil' then
+                match = 'Module:LibraryUtil'
+            end
+            table.insert( requireList, match )
+        end
+    end
+    for match in dualGmatch( content, 'mw%.loadData%s*(%b())', 'mw%.loadData%s*((["\'])%s*[Mm]odule:.-%2)' ) do
+        match = mw.text.trim( match )
+        match = extractModuleName( match, content )
+        if match:find( '%.%.' ) or match:find( '%%%a' ) then
+            for _, x in ipairs( getDynamicRequireList( match ) ) do
+                table.insert( dynamicLoadDataList, x )
+            end
+        elseif match ~= '' then
+            match = formatModuleName( match )
+            table.insert( loadDataList, match )
+        end
+    end
+    for func, match in string.gmatch( content, 'pcall%s*%(([^,]+),([^%),]+)' ) do
+        func = mw.text.trim( func )
+        match = mw.text.trim( match )
+        if func == 'require' then
+            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
+    if searchForUsedTemplates then
+        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
+                i = 0
+                return function()
+                    i = i + 1
+                    return list[i]
+                end
+            end
+            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
+    dynamicRequirelist = enum.reject( dynamicRequirelist, function(x) return (enum.contains(requireList, x) or enum.contains(loadDataList, x)) end )
+    dynamicLoadDataList = enum.reject( dynamicLoadDataList, function(x) return (enum.contains(requireList, x) or enum.contains(loadDataList, x)) end )
+    requireList = enum.insert( requireList, dynamicRequirelist )
+    requireList = enum.unique( requireList )
+    loadDataList = enum.insert( loadDataList, dynamicLoadDataList )
+    loadDataList = enum.unique( loadDataList )
+    usedTemplateList = enum.unique( usedTemplateList )
+    table.sort( requireList )
+    table.sort( loadDataList )
+    table.sort( usedTemplateList )
+    return requireList, loadDataList, usedTemplateList
+end
+--- Returns a list with module and function names used in all '{{#Invoke:moduleName|funcName}}' found on page 'templateName'.
+---@param templateName string
+---@return table<string, string>[]
+local function getInvokeCallList( templateName )
+    local content = mw.title.new( templateName ):getContent()
+    local invokeList = {}
+    assert( param.has_content( content ), string.format( '%s does not exist', templateName ) )
+    for moduleName, funcName in string.gmatch( content, '{{[{|safeubt:}]-#[Ii]nvoke:([^|]+)|([^}|]+)[^}]*}}' ) do
+        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
+    invokeList = enum.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
+---@param pageName string
+---@param addCategories boolean
+---@return string
+local function collapseList( list, id, listType )
+    local text = string.format( '%d %s', #list, listType )
+    local button = tooltip._span{ name=id, alt=text }
+    list = enum.map( list, function(x) return '\n# '..x end )
+    local content = tooltip._div{ name=id, content='\n'..table.concat( list )..'\n\n' }
+    return { tostring( button ) .. tostring( content ) }
+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.
+---@param query string      @This will be in a format like 'Module:Wowee/%' or 'Module:Wowee/%/data'
+---@return string
+local function formatDynamicQueryLink( query )
+    local prefix = query:match( '^([^/]+)' )
+    local linkText = query:gsub( '%%', '&lt; ... &gt;' )
+    query = query:gsub( '^Module:',  '' )
+    query = query:gsub( '([^/]+)/?', function ( match )
+        if match == '%' then
+            return '\\/[^\\/]+'
+        else
+            return '\\/"' .. match .. '"'
+        end
+    end )
+    query = query:gsub( '^\\/', '' )
+    query = string.format(
+        'intitle:/%s%s/i -intitle:/%s\\/""/i -intitle:doc prefix:"%s"',
+        query,
+        query:find( '"$' ) and '' or '""',
+        query,
+        prefix
+    )
+    return string.format( '<span class="plainlinks">[%s %s]</span>', tostring( mw.uri.fullUrl( 'Special:Search', { search = query } ) ), linkText )
+end
+---@param templateName string
+---@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 [[GSWiki:Lua|Lua]]''.</div>",
+            templateName,
+            item.funcName,
+            item.moduleName
+        ) )
+    end
+    if #invokeList > 0 then
+        table.insert( res, category )
+    end
+    return table.concat( res )
+end
+---@param moduleName string
+---@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 _, template in ipairs( templateData ) do
+        for _, invoke in ipairs( template.invokeList ) do
+            table.insert( invokedByList, string.format( "function '''%s''' is invoked by [[%s]]", invoke.funcName, template.templateName ) )
+        end
+    end
+    table.sort( invokedByList)
+    local res = {}
+    if #invokedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        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
+    if #templateData > 0 then
+        moduleIsUsed = true
+        table.insert( res, (addCategories and '[[Category:Template invoked modules]]' or '') )
+    end
+    return table.concat( res )
+end
+---@param moduleName string
+---@param addCategories boolean
+---@param whatLinksHere string      @A list generated by a dpl of pages in the Module namespace which link to moduleName.
+---@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 )
+    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 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 #requiredByList > 0 or #loadedByList > 0 then
+        moduleIsUsed  = true
+    end
+    if #requiredByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        requiredByList = collapseList( requiredByList, 'requiredBy', 'modules' )
+    end
+    if #loadedByList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        loadedByList = collapseList( loadedByList, 'loadedBy', 'modules' )
+    end
+    local res = {}
+    for _, requiredByModuleName in ipairs( requiredByList ) do
+        table.insert( res, string.format(
+            "<div class='seealso'>'''''%s''' is required by %s''.</div>",
+            moduleName,
+            requiredByModuleName
+        ) )
+    end
+    if #requiredByList > 0 then
+        table.insert( res, (addCategories and '[[Category:Modules required by modules]]' or '') )
+    end
+    for _, loadedByModuleName in ipairs( loadedByList ) do
+        table.insert( res, string.format(
+            "<div class='seealso'>'''''%s''' is loaded by %s''.</div>",
+            moduleName,
+            loadedByModuleName
+        ) )
+    end
+    if #loadedByList > 0 then
+        table.insert( res, (addCategories and '[[Category:Module data]]' or '') )
+    end
+    return table.concat( res )
+end
+local function formatRequireList( currentPageName, addCategories, requireList )
+    local res = {}
+    if #requireList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        requireList = collapseList( requireList, 'require', 'modules' )
+    end
+    for _, requiredModuleName in ipairs( requireList ) do
+        table.insert( res, string.format(
+            "<div class='seealso'>'''''%s''' requires %s.''</div>",
+            currentPageName,
+            requiredModuleName
+        ) )
+    end
+    if #requireList > 0 then
+        table.insert( res, (addCategories and '[[Category:Modules requiring modules]]' or '') )
+    end
+    return table.concat( res )
+end
+local function formatLoadDataList( currentPageName, addCategories, loadDataList )
+    local res = {}
+    if #loadDataList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        loadDataList = collapseList( loadDataList, 'loadData', 'modules' )
+    end
+    for _, loadedModuleName in ipairs( loadDataList ) do
+        table.insert( res, string.format(
+            "<div class='seealso'>'''''%s''' loads data from %s.''</div>",
+            currentPageName,
+            loadedModuleName
+        ) )
+    end
+    if #loadDataList > 0 then
+        table.insert( res, (addCategories and '[[Category:Modules using data]]' or '') )
+    end
+    return table.concat( res )
+end
+local function formatUsedTemplatesList( currentPageName, addCategories, usedTemplateList )
+    local res = {}
+    if #usedTemplateList > COLLAPSE_LIST_LENGTH_THRESHOLD then
+        usedTemplateList = collapseList( usedTemplateList, 'usedTemplates', 'templates' )
+    end
+    for _, templateName in ipairs( usedTemplateList ) do
+        table.insert( res, string.format(
+            "<div class='seealso'>'''''%s''' transcludes %s using <samp>frame:preprocess()</samp>.''</div>",
+            currentPageName,
+            templateName
+        ) )
+    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
+---@param currentPageName string|nil
+---@param addCategories boolean|string|nil
+---@return string
+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()
+    -- Leave early if not in module, template or calculator namespace or if module is part of exchange or data 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', 'Data'}, title.text:match( '^(.-)/' ) ) ) )
+    ) then
+        return ''
+    end
+    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 currentPageName:find( '^Template:' ) or currentPageName:find( '^Calculator:' ) then
+        local invokeList = getInvokeCallList( currentPageName )
+        return formatInvokeCallList( currentPageName, addCategories, invokeList )
+    end
+    local whatTemplatesLinkHere, whatModulesLinkHere = dpl.ask( {
+        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/%|Data/%|' .. currentPageName:gsub( 'Module:', '' ),
+        distinct = 'strict',
+        ignorecase = true,
+        ordermethod = 'title',
+        allowcachedresults = true,
+        cacheperiod = 604800 -- One week
+    } )
+    local requireList, loadDataList, usedTemplateList = getRequireList( currentPageName, true )
+    requireList = enum.map( requireList, function ( moduleName )
+        if moduleName:find( '%%' ) then
+            return formatDynamicQueryLink( moduleName )
+        else
+            return '[[' .. moduleName .. ']]'
+        end
+    end )
+    loadDataList = enum.map( loadDataList, function ( moduleName )
+        if moduleName:find( '%%' ) then
+            return formatDynamicQueryLink( moduleName )
+        else
+            return '[[' .. moduleName .. ']]'
+        end
+    end )
+    usedTemplateList = enum.map( usedTemplateList, function( templateName )
+        if string.find( templateName, ':' ) then -- Real templates are prefixed by a namespace, magic words are not
+            return '[['..templateName..']]'
+        else
+            return "'''&#123;&#123;"..templateName.."&#125;&#125;'''" -- Magic words don't have a page so make them bold instead
+        end
+    end )
+    local res = {}
+    table.insert( res, formatInvokedByList( currentPageName, addCategories, whatTemplatesLinkHere ) )
+    table.insert( res, formatRequireList( currentPageName, addCategories, requireList ) )
+    table.insert( res, formatLoadDataList( currentPageName, addCategories, loadDataList ) )
+    table.insert( res, formatUsedTemplatesList( currentPageName, addCategories, usedTemplateList ) )
+    table.insert( res, formatRequiredByList( currentPageName, addCategories, whatModulesLinkHere ) )
+    return table.concat( res )
+end
+return p
+-- </nowiki>

Module:DependencyList: Difference between revisions