Module:Pagetype

--------------------------------------------------------------------------------
--                                                                            --
--      This meta-module which automatically detects namespaces, and allows   --
--      for a great deal of customisation. It can easily be ported to other   --
--      wikis by changing the values in the [[Module:Pagetype/config]].       --
--                                                                            --
--------------------------------------------------------------------------------
-- Load config.
local cfg = mw.loadData('Module:Pagetype/config')

-- Load required modules.
local yesno = require('Module:Yesno')
local p = {}

-- Look up a namespace argument in the args table.
local function lookUpNamespaceArg(args, key)
 local arg = args[key]
 -- Convert "yes", "1" etc. to true, "no", "0" etc. to false, and leave
 -- other values the same.
 return yesno(arg, arg)
end

-- Append multiple values to an array
local function appendMultiple(target, source)
 for _, value in ipairs(source) do
  table.insert(target, value)
 end
end

-- Get argument keys for a title's namespace
local function getNamespaceArgKeys(title)
 local nsInfo = mw.site.namespaces[title.namespace]
 local customAliases = cfg.customNamespaceAliases[title.namespace] or {}
 local keys = {}
 if nsInfo.name ~= '' then
  table.insert(keys, nsInfo.name)
 end
 if nsInfo.canonicalName ~= nsInfo.name and nsInfo.canonicalName ~= '' then
  table.insert(keys, nsInfo.canonicalName)
 end
 appendMultiple(keys, nsInfo.aliases)
 appendMultiple(keys, customAliases)
 return keys
end

-- Get the argument for a title's namespace, if it was specified in the args table.
local function getNamespaceArg(title, args)
 if title.isTalkPage then
  return lookUpNamespaceArg(args, cfg.talk)
 end
 for _, key in ipairs(getNamespaceArgKeys(title)) do
  local arg = lookUpNamespaceArg(args, mw.ustring.lower(key))
  if arg ~= nil then
   return arg
  end
 end
 return nil
end

-- Look up a page type specific to the title's namespace
local function getExplicitPageType(title)
 if title.isTalkPage then
  return cfg.talkDefault
 else
  return cfg.pagetypes[title.namespace]
 end
end

-- Get a default page type that is not specific to the title's namespace
local function getDefaultPageType(args)
 local other = lookUpNamespaceArg(args, cfg.other)
 if type(other) == 'string' then
  return other
 else
  return cfg.otherDefault
 end
end

local function detectRedirects(title, args)
 local redirect = lookUpNamespaceArg(args, cfg.redirect)
 if redirect == false then
  -- Don't detect redirects if they have been specifically disallowed.
  return nil
 end

 -- Allow custom values for redirects.
 if not title.isRedirect then
  return nil
 elseif type(redirect) == 'string' then
  return redirect
 else
  return cfg.redirectDefault
 end
end

local function capitalize(pageType)
 local first = mw.ustring.sub(pageType, 1, 1)
 local rest = mw.ustring.sub(pageType, 2)
 return mw.ustring.upper(first) .. rest
end

local function pluralize(pageType)
 if cfg.irregularPlurals[pageType] then
  return cfg.irregularPlurals[pageType]
 else
  return pageType .. cfg.plural -- often 's'
 end
end

local function parseContent(title, args, optionsList)
 if title.namespace==828 and title.subpageText~='doc' -- don't detect modules
  or not title.exists -- can't check unless page exists
 then
  return nil
 end
 local content = title:getContent()
 if content == nil then
  return nil
 end
 local templates -- lazily evaluated
 for _, options in next, optionsList do
  local list, parameter, default, articleOnly = unpack(options, 1, 4)
  if not articleOnly or title.namespace==0 then -- only check for templates if we should...
   local out = lookUpNamespaceArg(args, parameter)
   if type(out) == "string" or (out ~= false and default) then -- ...and if we actually have anything to say about them
    if not templates then
     templates = {} -- do our delayed evaluation now that we are required to
     content = require('Module:Wikitext Parsing').PrepareText(content) -- disregard templates which do not have any affect
     for template in string.gmatch(content, "{{%s*([^|}]-)%s*[|}]") do
      templates[#templates+1] = capitalize(template)
     end
    end
    local wantedTemplates = mw.loadData('Module:Pagetype/' .. list)
    local templateFound = false
    for _, template in next, templates do
     if wantedTemplates[template] then
      templateFound = true
      break
     end
    end
    if templateFound then
     if type(out)=='string' then
      return out
     elseif out ~= false and default then
      return default
     end
    end
   end
  end
 end
end

-- Find pages which do not exist
local function nonExistent(title, args)
 local arg = lookUpNamespaceArg(args, cfg.ne)
 if arg == false then
  return nil
 end
 local exists = false
 if title.exists then -- not an article if it does not exist
  exists = true
 elseif title.namespace==8 and mw.message.new(title.text):exists() then
  exists = true
 elseif title.namespace==6 and title.fileExists then
  exists = true
 end
 if not exists then
  if type(arg) == 'string' then
   return arg
  else
   return cfg.naDefault
  end
 end
end

-- Get page types for mainspaces pages with an explicit class specified
local function getMainNamespaceClassPageType(title, args)
 local class = args[1]
 if type(class) == 'string' then -- Put in lower case so e.g. "na" and "NA" will both match
  class = mw.ustring.lower(class)
 end
 local arg = lookUpNamespaceArg(args, cfg.na)
 if arg == false then -- don't check for this class if it is specifically disallowed
  return nil
 end
 if cfg.naAliases[class] then
  if type(arg) == 'string' then
   return arg
  else
   return cfg.naDefault
  end
 else
  return nil
 end
end

-- Get page type specified by an explicit namespace argument.
local function getNamespaceArgPageType(title, args)
 local namespaceArg = getNamespaceArg(title, args)
 if namespaceArg == true then
  -- Namespace has been explicitly enabled, so return the default for
  -- this namespace
  return getExplicitPageType(title)
 elseif namespaceArg == false then
  -- Namespace has been explicitly disabled
  return getDefaultPageType(args)
 elseif namespaceArg then
  -- This namespaces uses custom text
  return namespaceArg
 else
  return nil
 end
end


-- Get page type not specified or detected by other means
local function getOtherPageType(title, args)
-- Whether the title is in the set of default active namespaces which are looked up in cfg.pagetypes.
 local isInDefaultActiveNamespace = false
 local defaultNamespacesKey = args[cfg.defaultns]
 if defaultNamespacesKey == cfg.defaultnsAll then
  isInDefaultActiveNamespace = true
 else
  local defaultNamespaces
  if defaultNamespacesKey == cfg.defaultnsExtended then
   defaultNamespaces = cfg.extendedNamespaces
  elseif defaultNamespacesKey == cfg.defaultnsNone then
   defaultNamespaces = {}
  else
   defaultNamespaces = cfg.defaultNamespaces
  end
  isInDefaultActiveNamespace = defaultNamespaces[title.namespace]
 end
 if isInDefaultActiveNamespace then
  return getExplicitPageType(title)
 else
  return getDefaultPageType(args)
 end
end

function p._main(args)
 local title
 if args.page then
  title = mw.title.new(args.page)
 else
  title = mw.title.getCurrentTitle()
 end
 if title and not yesno(args.talk, true) and args[cfg.defaultns] ~= cfg.defaultnsAll then
  title = title.subjectPageTitle
 end
 local pageType = detectRedirects(title, args)
  or nonExistent(title, args)
  or parseContent(title, args, {
   {'softredirect', cfg.softRedirect, cfg.softRedirectDefault},
   {'setindex', cfg.sia, cfg.siaDefault, true},
   {'disambiguation', cfg.dab, cfg.dabDefault, true},
   {'rfd', cfg.rfd, cfg.rfdDefault},
  })
  or (title.namespace == 0 and getMainNamespaceClassPageType(title, args))
  or getNamespaceArgPageType(title, args)
  or getOtherPageType(title, args)
 if yesno(args.plural, false) then
  pageType = pluralize(pageType)
 end
 if yesno(args.caps, false) then
  pageType = capitalize(pageType)
 end
 return pageType
end

function p.main(frame)
 local args = require('Module:Arguments').getArgs(frame)
 return p._main(args)
end

return p