Jump to content

Main menu Navigation ●Main page ●Contents ●Current events ●Random article ●About Wikipedia ●Contact us ●Donate Contribute ●Help ●Learn to edit ●Community portal ●Recent changes ●Upload file

●Create account ●Log in ●Create account ● Log in Pages for logged out editors learn more ●Contributions ●Talk

View source for Module:Pagetype

●Module ●Talk ●Read ●View source ●View history Tools Actions ●Read ●View source ●View history General ●What links here ●Related changes ●Upload file ●Special pages ●Page information ●Get shortened URL ●Download QR code ●Wikidata item ← Module:Pagetype You do not have permission to edit this page, for the following reasons:

This page is transcluded in a cascade-protected page, so only administrators can edit it.

Why is the page protected?

Cascading protection is used to prevent vandalism to particularly visible pages, such as the Main Page and a few very highly used templates.

This page is transcluded in the following page, which is protected with the "cascading" option:

Wikipedia:Cascade-protected items/content

What can I do?

Discuss this page with others.
For move-protected pages, see requested moves.
Request that the page's protection level be reduced.
Find out more about how to get started editing Wikipedia.
If you have noticed an error or have a suggestion for a simple, non-controversial change, you can submit an edit request by clicking the button below and following the instructions. An administrator may then make the change on your behalf. Please check the talk page first in case the issue is already being discussed.
Submit an edit request
If you wrote any text, please save it temporarily to your device until you can edit this page.

You can view and copy the source of this page:

--------------------------------------------------------------------------------
--                                                                            --
--      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[<span class="ltr">1</span>]
 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

●