Шаблон:Category handler/док — разлика између измена

Iz Vojne Enciklopedije
Пређи на навигацију Пређи на претрагу
[непроверена измена][непроверена измена]
м (Obsuser је преместио страницу Модул:Category handler/doc на Модул:Category handler/док)
м (1 измена увезена)
Ред 1: Ред 1:
{{module rating|beta}}
{{documentation subpage}}
{{high-risk|> 119000 страница односно {{#expr:(11900000/{{NUMBEROFPAGES:R}}) round 0}} % свих}}
{{#ifeq: {{FULLPAGENAME}} | Шаблон:Category handler | {{high-risk|> 24400}} }}
{{Module rating|p}}
{{lua|Module:Category handler}}
<!-- PLEASE ADD CATEGORIES AT THE BOTTOM OF THIS PAGE -->


This module implements the {{tl|category handler}} template. The category handler template helps other templates to automate both categorization and [[Wikipedia:Category suppression|category suppression]]. For information about using the category handler template in other templates, please see the '''[[Template:Category handler|template documentation]]'''. Keep reading for information about using the category handler module in other Lua modules, or for information on exporting this module to other wikis.
This is the {{tl|category handler}} meta-template.


== Use from other Lua modules ==
It helps other templates to automate both categorization and [[Wikipedia:Category suppression|category suppression]].


=== When not to use this module ===
Already when used with its default settings this template prevents auto-categorization in some namespaces and on some pages where we usually don't want categorization. Thus even the most basic usage like "<code><nowiki>{{category handler|[[Category:Somecat]]}}</nowiki></code>" sees to that templates don't auto-categorize in the wrong places.


For cases where a module only needs to categorise in one of the namespaces main (articles), file (images) or category, then using this module is overkill. Instead, you can simply get a title object using [[rev:https://www.mediawiki.org/wiki/Extension:Scribunto/Lua reference manual#mw.title.getCurrentTitle#mw.title.getCurrentTitle|mw.title.getCurrentTitle]] and check the <code>nsText</code> field. For example:
This template makes it easy to choose in what namespaces a template should and should not categorize. And it makes it easy to use different categories in different namespaces. And this template uses a central blacklist where we can add pages and page types where templates should not auto-categorize.
<source lang="lua">
 
local title = mw.title.getCurrentTitle()
=== When not to use this template ===
if title.nsText == 'File' then
 
    -- do something
If a template only needs to categorize in one of the namespaces main (articles), file (images) or category, then using this template is overkill. Then instead use one of {{tl|main other}}, {{tl|file other}}, or {{tl|category other}}. But if your template needs to categorize in any other namespace, then we recommend you use this template, since it provides proper category suppression and makes it easy to select how to categorize in the different namespaces.
end
</source>
However, if your module needs to categorize in any other namespace, then we recommend you use this module, since it provides proper category suppression and makes it easy to select how to categorize in the different namespaces.


=== Namespaces ===
=== Namespaces ===


This module detects and groups all the different [[Wikipedia:Namespace|namespaces]] used on Wikipedia into several types. These types are used as parameter names in this module.
This template detects and groups all the different [[Wikipedia:Namespace|namespaces]] used on Wikipedia into several types. These types are used as parameter names in this template.


:'''main''' = Main/article space, as in normal Wikipedia articles.
:'''main''' = Main/article space, as in normal Wikipedia articles.
:'''talk''' = Any talk space, such as page names that start with "Talk:", "User talk:", "File talk:" and so on.
:'''talk''' = Any talk space, such as page names that start with "Talk:", "User talk:", "File talk:" and so on.
:'''user, wikipedia, file ... = The other namespaces except the talk pages. Namespace aliases are also accepted. See the table below for the full list.
:'''user, wikipedia, file, mediawiki, template, help, category, portal''' and '''book''' = The other namespaces except the talk pages.
:'''other''' = Any namespaces that were not specified as a parameter to the template. See examples below.
:'''other''' = Any namespaces that were not specified as a parameter to the template. See examples below.
;List of possible namespace parameters
(excluding <code>''talk''</code> and <code>''other''</code>)
{{#invoke:Namespace detect|table}}


=== Basic usage ===
=== Basic usage ===


This module takes two or more parameters. Here's an example using a hello world program:
This template takes two or more parameters. Here's an example with the full template code for an article message box:


<source lang="lua">
<pre>
p = {}
{{Ambox
local categoryHandler = require( 'Module:Category handler' ).main
| text = This is a box used in articles.
}}{{category handler
function p.main( frame )
| [[Category:Somecat]]
    local result = 'Hello world!'
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
    local category = categoryHandler{
}}<noinclude>
        '[[Category:Somecat]]',
{{Documentation}}
        nocat = frame.args.nocat -- So "nocat=true/false" works
<!--Add categories to the /doc subpage-->
    }
</noinclude>
    category = category or '' -- Check that we don't have a nil value for the category variable.
</pre>
    return result .. category
end
return p
</source>


The above example uses the default settings for the category handler module. That means the example module will categorize on pages in the following namespaces:  
The above example uses the default settings for {{tlf|category handler}}. That means the box will categorize on pages in the following namespaces:  
:'''main''', '''file''', '''help''', '''category''', '''portal''' and '''book'''
:'''main''', '''file''', '''help''', '''category''', '''portal''' and '''book'''
But it will ''not'' categorize in any other namespaces, e.g.:
But it will ''not'' categorize in the following namespaces:
:'''talk''', '''user''', '''wikipedia''', '''mediawiki''', '''template''' ...
:'''talk''', '''user''', '''wikipedia''', '''mediawiki''' and '''template'''


And it will ''not'' categorize on blacklisted pages. (See section [[#Blacklist|blacklist]] below.)
And it will ''not'' categorize on blacklisted pages. (See section [[#Blacklist|blacklist]] below.)


The reason the category handler module does not categorize in some of the namespaces is that in those namespaces most modules and templates are just demonstrated or listed, not used. Thus most modules and templates should not categorize in those namespaces.  
The reason this template does not categorize in some of the namespaces is that in those namespaces most templates are just demonstrated or listed, not used. Thus most templates should not categorize in those namespaces.  


Any module or template that is meant for one or more of the namespaces where this module categorizes can use the basic syntax as shown above.
Any template that is meant for one or more of the namespaces where this template categorizes can use the basic syntax as shown above.


=== Advanced usage ===
=== Advanced usage ===


This module takes one or more parameters named after the different page types as listed in section [[#Namespaces|namespaces]] above. By using those parameters you can specify exactly in which namespaces your template should categorize. Like this:
This template takes one or more parameters named after the different page types as listed in section [[#Namespaces|namespaces]] above. By using those parameters you can specify exactly in which namespaces your template should categorize. Like this:


<source lang="lua">
<pre>
p = {}
{{mbox
local categoryHandler = require( 'Module:Category handler' ).main
| text = This is a box for articles and talk pages.
}}{{category handler
function p.main( frame )
| main = [[Category:Somecat1]]   <!--Categorize in main (article) space-->
    local result = 'This is a module meant for articles and talk pages.'
| talk = [[Category:Somecat2]]   <!--Categorize in talk space-->
    local category = categoryHandler{
| nocat = {{{nocat|}}}  <!--So "nocat=true" works-->
        main = '[[Category:Somecat1]]', -- Categorize in main (article) space
}}
        talk = '[[Category:Somecat2]]', -- Categorize in talk space
</pre>
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end
return p
</source>


The above module will only categorize in main and talk space. But it will not categorize on /archive pages since they are blacklisted. (See section [[#Blacklist|blacklist]] below.) And if you need to demonstrate (discuss) the module on a talkpage, then you can feed "<code>nocat='true'</code>" to prevent that template from categorizing. (See section [[#Nocat|nocat]] below.) Like this:
The above box will only categorize in main and talk space. But it will not categorize on /archive pages since they are blacklisted. (See section [[#Blacklist|blacklist]] below.) And if you need to demonstrate (discuss) that box on a talkpage, then you can feed "<code>nocat=true</code>" to prevent that template from categorizing. (See section [[#Nocat|nocat]] below.) Like this:


<pre>
<pre>
== My new module ==
== My new template ==
Hey guys, have you seen my new module?
Hey guys, have you seen my new template?
{{#invoke:mymodule|main|nocat=true}}
{{mytemp|nocat=true}}
Nice, isn't it?
Nice, isn't it?
--~~~~
--~~~~
Ред 97: Ред 78:
Sometimes we want to use the same category in several namespaces, then do like this:
Sometimes we want to use the same category in several namespaces, then do like this:


<source lang="lua">
<pre>
p = {}
{{mbox
local categoryHandler = require( 'Module:Category handler' ).main
| text = This is a box used in several namespaces.
}}{{category handler
function p.main( frame )
| main = [[Category:Somecat1]]
    local result = 'This is a module used in several namespaces.'
| 1 = [[Category:Somecat2]]   <!--For help and user space-->
    local category = categoryHandler{
| help = 1
        main = '[[Category:Somecat1]]',
| user = 1
        [ 1 ] = '[[Category:Somecat2]]', -- For help and user space
| talk =     <!--No categories on talk pages-->
        help = 1,
| other = [[Category:Somecat3]]   <!--For all other namespaces-->
        user = 1,
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
        talk = '', -- No categories on talk pages
}}
        other = '[[Category:Somecat3]]', -- For all other namespaces
</pre>
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end
return p
</source>


In the above example we use a numbered parameter to feed one of the categories, and then we tell this module to use that numbered parameter for both the help and user space.
In the above example we use a numbered parameter to feed one of the categories, and then we tell this template to use that numbered parameter for both the help and user space.


The category handler module understands an unlimited number of numbered parameters.
This template understands the numbered parameters 1 to 10.


The '''other''' parameter defines what should be used in the remaining namespaces that have not explicitly been fed data.
The '''other''' parameter defines what should be used in the remaining namespaces that have not explicitly been fed data.


Note the empty but defined '''talk''' parameter. That stops this module from showing what has been fed to the '''other''' parameter, when in talk space.
Note the empty but defined '''talk''' parameter. That stops this template from showing what has been fed to the '''other''' parameter, when in talk space.


The category handler module also has a parameter called '''all'''. It works like this:
This template also has a parameter called '''all'''. It works like this:


<source lang="lua">
<pre>
p = {}
{{mbox
local categoryHandler = require( 'Module:Category handler' ).main
| text = This is a box used in all namespaces.
}}{{category handler
function p.main( frame )
| all = [[Category:Somecat1]]   <!--Categorize in all namespaces-->
    local result = 'This is a module used in all namespaces.'
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
    local category = categoryHandler{
}}
        all = '[[Category:Somecat1]]', -- Categorize in all namespaces
</pre>
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end
return p
</source>


The above example will categorize in all namespaces, but not on blacklisted pages. If you want to demonstrate that module on a page, then use "<code>nocat=true</code>" to prevent the template from categorizing.  
The above example will categorize in all namespaces, but not on blacklisted pages. If you want to demonstrate that box on a page, then use "<code>nocat=true</code>" to prevent the template from categorizing.  


We suggest avoiding the '''all''' parameter, since modules and templates should preferably only categorize in the namespaces they need to.
We suggest avoiding the '''all''' parameter, since templates should preferably only categorize in the namespaces they need to.


The all parameter can also be combined with the rest of the parameters. Like this:
The all parameter can also be combined with the rest of the parameters. Like this:


<source lang="lua">
<pre>
p = {}
{{mbox
local categoryHandler = require( 'Module:Category handler' ).main
| text = This is a box used in all namespaces.
}}{{category handler
function p.main( frame )
| all = [[Category:Somecat1]]   <!--Categorize in all namespaces-->
    local result = 'This is a module used in all namespaces.'
| main = [[Category:Somecat2]]   <!--And add this in main space-->
    local category = categoryHandler{
| other = [[Category:Somecat3]]   <!--And add this in all other namespaces-->
        all = '[[Category:Somecat1]]', -- Categorize in all namespaces
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
        main = '[[Category:Somecat2]]', -- And add this in main space
}}
        other = '[[Category:Somecat3]]', -- And add this in all other namespaces
</pre>
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end
return p
</source>


If the above module is placed on an article, then it will add the categories "Somecat1" and "Somecat2". But on all other types of pages it will instead add "Somecat1" and "Somecat3". As the example shows, the all parameter works independently of the rest of the parameters.
If the above box is placed on an article, then it will add the categories "Somecat1" and "Somecat2". But on all other types of pages it will instead add "Somecat1" and "Somecat3". As the example shows, the all parameter works independently of the rest of the parameters.


=== Subpages ===
=== Subpages ===


The category handler module understands the '''subpage''' parameter. Like this:
This template understands the '''subpage''' parameter. Like this:


<source lang="lua">
<pre>
p = {}
{{category handler
local categoryHandler = require( 'Module:Category handler' ).main
| subpage = no   <!--Don't categorize on subpages-->
| wikipedia = [[Category:Somecat]]
function p.main( frame )
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
    local result = 'This is a module used in all namespaces.'
}}
    local category = categoryHandler{
</pre>
        subpage = 'no' -- Don't categorize on subpages
        wikipedia = '[[Category:Somecat]]',
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end
return p
</source>


If "<code>subpage='no'</code>" then this template will ''not'' categorize on subpages. For the rare occasion you ''only'' want to categorize on subpages, then use "<code>subpage='only'</code>". If '''subpage''' is empty or undefined then this template categorizes both on basepages and on subpages.
If "<code>subpage=no</code>" then this template will ''not'' categorize on subpages. For the rare occasion you ''only'' want to categorize on subpages, then use "<code>subpage=only</code>". If '''subpage''' is empty or undefined then this template categorizes both on basepages and on subpages.


=== Blacklist ===
=== Blacklist ===


This module has a blacklist of the pages and page types where templates should not auto-categorize. Thus modules that use this meta-template will for instance not categorize on /archive pages and on the subpages of [[Wikipedia:Template messages]].
This template has a blacklist of the pages and page types where templates should not auto-categorize. Thus templates that use this meta-template will for instance not categorize on /archive pages and on the subpages of [[Wikipedia:Template messages]].


If you want a template to categorize on a blacklisted page, then feed "<code><nowiki>nocat = false</nowiki></code>" to the module when you place it on the page, thus skipping the blacklist check. Note that this module only categorizes if it has data for the namespace. For instance, if the basic syntax is used (see [[#Basic usage|basic usage]] above), then even if you set "<code>nocat = false</code>" the template will not categorize on a talk page, since it has no data for talk pages. But it has data for help space, so on a blacklisted help page it will categorize.
If you want a template to categorize on a blacklisted page, then feed "<code><nowiki>nocat = false</nowiki></code>" to the template when you place it on the page, thus skipping the blacklist check. Note that this template only categorizes if it has data for the namespace. For instance, if the basic syntax is used (see [[#Basic usage|basic usage]] above), then even if you set "<code>nocat = false</code>" the template will not categorize on a talk page, since it has no data for talk pages. But it has data for help space, so on a blacklisted help page it will categorize.


The blacklist is located in the configuration table <code>cfg.blacklist</code> near the top of the module code.
The blacklist is in the sub-template {{tl|category handler/blacklist}}. To see or update the blacklist, go there.


=== The "nocat" parameter ===
=== The "nocat" parameter ===


This module understands the '''nocat''' parameter:
This template understands the '''nocat''' parameter:


* If "<code>nocat = true</code>" then this template does ''not'' categorize.
* If "<code>nocat = true</code>" then this template does ''not'' categorize.  
* If '''nocat''' is <code>nil</code> then this template categorizes as usual.  
* If '''nocat''' is empty or undefined then this template categorizes as usual.  
* If "<code>nocat = false</code>" this template categorizes even when on blacklisted pages. (See section [[#Blacklist|blacklist]] above.)
* If "<code>nocat = false</code>" this template categorizes even when on blacklisted pages. (See section [[#Blacklist|blacklist]] above.)
* The nocat parameter also accepts aliases for <code>true</code> and <code>false</code> as defined by [[Module:Yesno]], e.g. "yes", "y", "true", and 1 for <code>true</code>, and "no", "n", "false", and 0 for <code>false</code>.


Modules and templates that use {{tlf|category handler}} should forward '''nocat''', so they too understand '''nocat'''. The code "<code>nocat = frame.args.nocat</code>" shown in the examples on this page does that.
Templates that use {{tlf|category handler}} should forward '''nocat''', so they too understand '''nocat'''. The code "<code><nowiki>nocat = {{{nocat|}}}</nowiki></code>" shown in the examples on this page does that.


=== The "categories" parameter ===
=== The "categories" parameter ===


For backwards compatibility this module also understands the '''categories''' parameter. It works the same as '''nocat'''. Like this:
For backwards compatibility this template also understands the '''categories''' parameter. It works the same as '''nocat'''. Like this:


* If "<code>categories = false</code>" then this template does ''not'' categorize.  
* If "<code>categories = no</code>" then this template does ''not'' categorize.  
* If '''categories''' is empty or undefined then this template categorizes as usual.  
* If '''categories''' is empty or undefined then this template categorizes as usual.  
* If "<code>categories = true</code>" this template categorizes even when on blacklisted pages.
* If "<code>categories = yes</code>" this template categorizes even when on blacklisted pages.
* The categories parameter also accepts aliases for <code>true</code> and <code>false</code> as defined by [[Module:Yesno]], e.g. "yes", "y", "true", and 1 for <code>true</code>, and "no", "n", "false", and 0 for <code>false</code>.
 
When adding this template to a template that already uses the "<code>categories = no</code>" logic, then you can do the following to not break any existing usage:
 
<pre>
{{category handler
| [[Category:Somecat]]
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
| categories = {{{categories|}}}  <!--So "categories=no" works-->
}}
</pre>


=== The "category2" parameter ===
=== The "category2" parameter ===


For backwards compatibility this template kind of supports the old "category =" parameter. But the parameter name "category" is already used in this module to feed category data for when in category space. So instead this template uses '''category2''' for the usage similar to '''nocat'''. Like this:
For backwards compatibility this template kind of supports the old "category =" parameter. But the parameter name "category" is already used in this template to feed category data for when in category space. So instead this template uses '''category2''' for the usage similar to '''nocat'''. Like this:
 
* If "<code>category2 =</code>" (empty but defined), or "<code>category2 = no</code>", or if '''category2''' is fed any other data (except as described in the next two points), then this template does ''not'' categorize.
* If '''category2''' is undefined or if "<code>category2 = ¬</code>", then this template categorizes as usual.
* If "<code>category2 = yes</code>" this template categorizes even when on blacklisted pages.


* If "<code>category2 = ''</code>" (empty but defined), or "<code>category2 = 'no'</code>", or if '''category2''' is fed any other data (except as described in the next two points), then this template does ''not'' categorize.
When adding this template to a template that already uses the "<code>category =</code>" logic, then you can do like this to not break any existing usage:
* If '''category2''' is undefined or if "<code>category2 = '¬'</code>", then this template categorizes as usual.
* If "<code>category2 = 'yes'</code>" this template categorizes even when on blacklisted pages.


=== Categories and text ===
<pre>
{{category handler
| [[Category:Somecat]]
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
| category2 = {{{category|¬}}}  <!--So "category =" works-->
}}
</pre>


Besides from categories, you can feed anything else to this module, for instance some text. Like this:
Note that the "<code>¬</code>" is necessary, it helps this template to detect if the '''category''' parameter is defined but empty, or undefined.


<source lang="lua">
=== Categories and text ===
p = {}
local categoryHandler = require( 'Module:Category handler' ).main


function p.main( frame )
Besides from categories, you can feed anything else to this template, for instance some text. Like this:
    local result = 'This is a module used on talk pages.'
    local category = categoryHandler{
        talk = '[[Category:Somecat]]',
        other = '<p class="error">This module should only be used on talk pages.</p>',
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end


return p
<pre>
</source>
{{tmbox
| text = This is a talk page message box.
}}{{category handler
| talk = [[Category:Somecat]]
| other = :::::This template should only be used on talk pages.
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
}}
</pre>


When the module code above is used on anything other than a talk page, it will look like this:
When the template above is shown on anything else than a talk page, it will look like this (note the text below the box):


:This is a module used on talk pages.{{#invoke:category handler|main
{{tmbox
| text = This is a talk page message box.
| nocat = true    <!--So this box doesn't add "Category:Talk message boxes"-->
}}{{category handler
| talk = [[Category:Somecat]]
| talk = [[Category:Somecat]]
| other = <p class="error">This module should only be used on talk pages.</p>
| other = :::::This template should only be used on talk pages.
| nocat = {{{nocat|}}} <!--So "nocat=true/false" works-->
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}
}}


That text will not show on blacklisted pages, so don't use this method to show any important information. Feeding "<code>nocat = 'true'</code>" to the template hides the text, just as it suppresses any categories.
That text will not show on blacklisted pages, so don't use this method to show any important information. Feeding "<code>nocat = true</code>" to the template hides the text, just as it suppresses any categories.


=== The "page" parameter ===
=== The "page" parameter ===


For testing and demonstration purposes this module can take a parameter named '''page'''. Like this:
For testing and demonstration purposes this template can take a parameter named '''page'''. Like this:


<source lang="lua">
<pre>
p = {}
{{category handler
local categoryHandler = require( 'Module:Category handler' ).main
| main = Category:Some cat
| talk = Category:Talk cat
function p.main( frame )
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
    local category = categoryHandler{
| page = User talk:Example
        main = 'Category:Some cat',
}}
        talk = 'Category:Talk cat',
</pre>
        nocat = frame.args.nocat, -- So "nocat=true/false" works
        page = 'User talk:Example'
    }
    return category
end
return p
</source>


In the above code we on purpose left out the brackets around the category names so we see the output on the page. No matter on what kind of page the code above is used it will return this:
In the above code we on purpose left out the brackets around the category names so we see the output on the page. No matter on what kind of page the code above is used it will return this:


:{{#invoke:category handler|main
:{{category handler
| main = Category:Some cat
| main = Category:Some cat
| talk = Category:Talk cat
| talk = Category:Talk cat
Ред 295: Ред 249:
}}
}}


The '''page''' parameter makes this module behave exactly as if on that page. Even the blacklist works. The pagename doesn't have to be an existing page.
The '''page''' parameter makes this template behave exactly as if on that page. Even the blacklist works. The pagename doesn't have to be an existing page.


If the '''page''' parameter is empty or undefined, the name of the current page determines the result.
If the '''page''' parameter is empty or undefined, the name of the current page determines the result.


You can make it so your module also understands the '''page''' parameter. That means you can test how your template will categorize on different pages, without having to actually edit those pages. Then do like this:
You can make it so your template also understands the '''page''' parameter. That means you can test how your template will categorize on different pages, without having to actually edit those pages. Then do like this:


<source lang="lua">
<pre>
p = {}
{{category handler
local categoryHandler = require( 'Module:Category handler' ).main
| main = Category:Some cat
| talk = Category:Talk cat
| nocat = {{{nocat|}}}  <!--So "nocat=true/false" works-->
| page = {{{page|}}}  <!--For testing-->
}}
</pre>


function p.main( frame )
=== Parameters ===
    local category = categoryHandler{
        main = 'Category:Some cat',
        talk = 'Category:Talk cat',
        nocat = frame.args.nocat, -- So "nocat=true/false" works
        page = frame.args.page -- For testing
    }
    return category
end


return p
List of all parameters:
</source>


=== Parameters ===
<pre>
{{category handler
| [[Category:Somecat]]
| subpage = no / only
| 1 =
...
| 10 =
| all = [[Category:Somecat]] / Text
| main = 1 / ... / 10 / [[Category:Somecat]] / Text
...
| other = 1 / ... / 10 / [[Category:Somecat]] / Text


List of all parameters:
| nocat = {{{nocat|}}} / true / false
| categories = {{{categories|}}} / no / yes
| category2 = {{{category|¬}}} / 'empty' / no / 'not defined' / ¬ / yes


* First positional parameter - for default settings
| page  = {{{page|}}} / User:Example
* subpage = 'no' / 'only'
}}
* 1, 2, 3 ...
</pre>
* all = '<nowiki>[[Category:Somecat]]</nowiki>' / 'Text'
* main = 1, 2, 3 ... / '<nowiki>[[Category:Somecat]]</nowiki>' / 'Text'
* ...
* other = 1, 2, 3 ... / '<nowiki>[[Category:Somecat]]</nowiki>' / 'Text'
* nocat = frame.args.nocat / true / false / 'yes' / 'no' / 'y' / 'n' / 'true' / 'false' / 1 / 0
* categories = frame.args.categories / false / true / 'no' / 'yes' / 'n' / 'y' / 'false' / 'true' / 0 / 1
* category2 = frame.args.category or '¬' / '' / 'no' / ''not defined'' / '¬' / 'yes'
* page  = frame.args.page / 'User:Example'


Note that empty values to the "main" ... "other" parameters have special meaning (see examples above). The "all" parameter doesn't understand numbered parameters, since there should never be a need for that.
Note that empty values to the "main" ... "other" parameters have special meaning (see examples above). The "all" parameter doesn't understand numbered parameters, since there should never be a need for that.


== Exporting to other wikis ==
=== Technical details ===
The centralised category suppression blacklist is in the sub-template {{tl|category handler/blacklist}}. To see or update the blacklist, go there.


This module can be exported to other wikis by changing the configuration values in the <code>cfg</code> table. All the variable values are configurable, so after the configuration values have been set there should be no need to alter the main module code. Details of each configuration value are included in the module code comments. In addition, this module requires [[Module:Namespace detect]] to be available on the local wiki.
For its internal parameter processing, this template uses the sub-template {{tl|category handler/numbered}}.


== See also ==
For more technical details see the [[Template talk:Category handler|talk page]].


* {{tl|Category handler}} – for using this module with templates, rather than Lua modules.
=== See also ===
* [[Wikipedia:Category suppression]] – The how-to guide.
* [[Wikipedia:Category suppression]] – The how-to guide.
* [[Wikipedia:WikiProject Category Suppression]] – The WikiProject.
* [[Wikipedia:WikiProject Category Suppression]] – The WikiProject.
* [[Wikipedia:Namespace]] – Lists all the namespaces.
* [[Wikipedia:Namespace]] – Lists all the namespaces.
<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
[[Kategorija:Помоћни шаблони|{{PAGENAME}}]]
[[Category:Wikipedia metatemplates]]
}}</includeonly>

Верзија на датум 5. фебруар 2021. у 13:22

Lua error: Cannot create process: proc_open(/dev/null): failed to open stream: Operation not permitted

Lua error: Cannot create process: proc_open(/dev/null): failed to open stream: Operation not permitted

This is the {{category handler}} meta-template.

It helps other templates to automate both categorization and category suppression.

Already when used with its default settings this template prevents auto-categorization in some namespaces and on some pages where we usually don't want categorization. Thus even the most basic usage like "{{category handler|[[Category:Somecat]]}}" sees to that templates don't auto-categorize in the wrong places.

This template makes it easy to choose in what namespaces a template should and should not categorize. And it makes it easy to use different categories in different namespaces. And this template uses a central blacklist where we can add pages and page types where templates should not auto-categorize.

When not to use this template

If a template only needs to categorize in one of the namespaces main (articles), file (images) or category, then using this template is overkill. Then instead use one of {{main other}}, {{file other}}, or {{category other}}. But if your template needs to categorize in any other namespace, then we recommend you use this template, since it provides proper category suppression and makes it easy to select how to categorize in the different namespaces.

Namespaces

This template detects and groups all the different namespaces used on Wikipedia into several types. These types are used as parameter names in this template.

main = Main/article space, as in normal Wikipedia articles.
talk = Any talk space, such as page names that start with "Talk:", "User talk:", "File talk:" and so on.
user, wikipedia, file, mediawiki, template, help, category, portal and book = The other namespaces except the talk pages.
other = Any namespaces that were not specified as a parameter to the template. See examples below.

Basic usage

This template takes two or more parameters. Here's an example with the full template code for an article message box:

{{Ambox
| text = This is a box used in articles.
}}{{category handler
| [[Category:Somecat]]
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}<noinclude>
{{Documentation}}
<!--Add categories to the /doc subpage-->
</noinclude>

The above example uses the default settings for {{category handler}}. That means the box will categorize on pages in the following namespaces:

main, file, help, category, portal and book

But it will not categorize in the following namespaces:

talk, user, wikipedia, mediawiki and template

And it will not categorize on blacklisted pages. (See section blacklist below.)

The reason this template does not categorize in some of the namespaces is that in those namespaces most templates are just demonstrated or listed, not used. Thus most templates should not categorize in those namespaces.

Any template that is meant for one or more of the namespaces where this template categorizes can use the basic syntax as shown above.

Advanced usage

This template takes one or more parameters named after the different page types as listed in section namespaces above. By using those parameters you can specify exactly in which namespaces your template should categorize. Like this:

{{mbox
| text = This is a box for articles and talk pages.
}}{{category handler
| main = [[Category:Somecat1]]   <!--Categorize in main (article) space-->
| talk = [[Category:Somecat2]]   <!--Categorize in talk space-->
| nocat = {{{nocat|}}}   <!--So "nocat=true" works-->
}}

The above box will only categorize in main and talk space. But it will not categorize on /archive pages since they are blacklisted. (See section blacklist below.) And if you need to demonstrate (discuss) that box on a talkpage, then you can feed "nocat=true" to prevent that template from categorizing. (See section nocat below.) Like this:

== My new template ==
Hey guys, have you seen my new template?
{{mytemp|nocat=true}}
Nice, isn't it?
--~~~~

Sometimes we want to use the same category in several namespaces, then do like this:

{{mbox
| text = This is a box used in several namespaces.
}}{{category handler
| main = [[Category:Somecat1]]
| 1 = [[Category:Somecat2]]   <!--For help and user space-->
| help = 1
| user = 1
| talk =     <!--No categories on talk pages-->
| other = [[Category:Somecat3]]   <!--For all other namespaces-->
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}

In the above example we use a numbered parameter to feed one of the categories, and then we tell this template to use that numbered parameter for both the help and user space.

This template understands the numbered parameters 1 to 10.

The other parameter defines what should be used in the remaining namespaces that have not explicitly been fed data.

Note the empty but defined talk parameter. That stops this template from showing what has been fed to the other parameter, when in talk space.

This template also has a parameter called all. It works like this:

{{mbox
| text = This is a box used in all namespaces.
}}{{category handler
| all = [[Category:Somecat1]]   <!--Categorize in all namespaces-->
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}

The above example will categorize in all namespaces, but not on blacklisted pages. If you want to demonstrate that box on a page, then use "nocat=true" to prevent the template from categorizing.

We suggest avoiding the all parameter, since templates should preferably only categorize in the namespaces they need to.

The all parameter can also be combined with the rest of the parameters. Like this:

{{mbox
| text = This is a box used in all namespaces.
}}{{category handler
| all = [[Category:Somecat1]]   <!--Categorize in all namespaces-->
| main = [[Category:Somecat2]]   <!--And add this in main space-->
| other = [[Category:Somecat3]]   <!--And add this in all other namespaces-->
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}

If the above box is placed on an article, then it will add the categories "Somecat1" and "Somecat2". But on all other types of pages it will instead add "Somecat1" and "Somecat3". As the example shows, the all parameter works independently of the rest of the parameters.

Subpages

This template understands the subpage parameter. Like this:

{{category handler
| subpage = no    <!--Don't categorize on subpages-->
| wikipedia = [[Category:Somecat]]
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}

If "subpage=no" then this template will not categorize on subpages. For the rare occasion you only want to categorize on subpages, then use "subpage=only". If subpage is empty or undefined then this template categorizes both on basepages and on subpages.

Blacklist

This template has a blacklist of the pages and page types where templates should not auto-categorize. Thus templates that use this meta-template will for instance not categorize on /archive pages and on the subpages of Wikipedia:Template messages.

If you want a template to categorize on a blacklisted page, then feed "nocat = false" to the template when you place it on the page, thus skipping the blacklist check. Note that this template only categorizes if it has data for the namespace. For instance, if the basic syntax is used (see basic usage above), then even if you set "nocat = false" the template will not categorize on a talk page, since it has no data for talk pages. But it has data for help space, so on a blacklisted help page it will categorize.

The blacklist is in the sub-template {{category handler/blacklist}}. To see or update the blacklist, go there.

The "nocat" parameter

This template understands the nocat parameter:

  • If "nocat = true" then this template does not categorize.
  • If nocat is empty or undefined then this template categorizes as usual.
  • If "nocat = false" this template categorizes even when on blacklisted pages. (See section blacklist above.)

Templates that use {{category handler}} should forward nocat, so they too understand nocat. The code "nocat = {{{nocat|}}}" shown in the examples on this page does that.

The "categories" parameter

For backwards compatibility this template also understands the categories parameter. It works the same as nocat. Like this:

  • If "categories = no" then this template does not categorize.
  • If categories is empty or undefined then this template categorizes as usual.
  • If "categories = yes" this template categorizes even when on blacklisted pages.

When adding this template to a template that already uses the "categories = no" logic, then you can do the following to not break any existing usage:

{{category handler
| [[Category:Somecat]]
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
| categories = {{{categories|}}}   <!--So "categories=no" works-->
}}

The "category2" parameter

For backwards compatibility this template kind of supports the old "category =" parameter. But the parameter name "category" is already used in this template to feed category data for when in category space. So instead this template uses category2 for the usage similar to nocat. Like this:

  • If "category2 =" (empty but defined), or "category2 = no", or if category2 is fed any other data (except as described in the next two points), then this template does not categorize.
  • If category2 is undefined or if "category2 = ¬", then this template categorizes as usual.
  • If "category2 = yes" this template categorizes even when on blacklisted pages.

When adding this template to a template that already uses the "category =" logic, then you can do like this to not break any existing usage:

{{category handler
| [[Category:Somecat]]
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
| category2 = {{{category|¬}}}   <!--So "category =" works-->
}}

Note that the "¬" is necessary, it helps this template to detect if the category parameter is defined but empty, or undefined.

Categories and text

Besides from categories, you can feed anything else to this template, for instance some text. Like this:

{{tmbox
| text = This is a talk page message box.
}}{{category handler
| talk = [[Category:Somecat]]
| other = :::::This template should only be used on talk pages.
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
}}

When the template above is shown on anything else than a talk page, it will look like this (note the text below the box):

Lua error: Cannot create process: proc_open(/dev/null): failed to open stream: Operation not permittedLua error: Cannot create process: proc_open(/dev/null): failed to open stream: Operation not permitted

That text will not show on blacklisted pages, so don't use this method to show any important information. Feeding "nocat = true" to the template hides the text, just as it suppresses any categories.

The "page" parameter

For testing and demonstration purposes this template can take a parameter named page. Like this:

{{category handler
| main = Category:Some cat
| talk = Category:Talk cat
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
| page = User talk:Example
}}

In the above code we on purpose left out the brackets around the category names so we see the output on the page. No matter on what kind of page the code above is used it will return this:

Lua error: Cannot create process: proc_open(/dev/null): failed to open stream: Operation not permitted

The page parameter makes this template behave exactly as if on that page. Even the blacklist works. The pagename doesn't have to be an existing page.

If the page parameter is empty or undefined, the name of the current page determines the result.

You can make it so your template also understands the page parameter. That means you can test how your template will categorize on different pages, without having to actually edit those pages. Then do like this:

{{category handler
| main = Category:Some cat
| talk = Category:Talk cat
| nocat = {{{nocat|}}}   <!--So "nocat=true/false" works-->
| page = {{{page|}}}   <!--For testing-->
}}

Parameters

List of all parameters:

{{category handler
| [[Category:Somecat]]
| subpage = no / only
| 1 =
...
| 10 =
| all = [[Category:Somecat]] / Text
| main = 1 / ... / 10 / [[Category:Somecat]] / Text
...
| other = 1 / ... / 10 / [[Category:Somecat]] / Text

| nocat = {{{nocat|}}} / true / false
| categories = {{{categories|}}} / no / yes
| category2 = {{{category|¬}}} / 'empty' / no / 'not defined' / ¬ / yes

| page  = {{{page|}}} / User:Example
}}

Note that empty values to the "main" ... "other" parameters have special meaning (see examples above). The "all" parameter doesn't understand numbered parameters, since there should never be a need for that.

Technical details

The centralised category suppression blacklist is in the sub-template {{category handler/blacklist}}. To see or update the blacklist, go there.

For its internal parameter processing, this template uses the sub-template {{category handler/numbered}}.

For more technical details see the talk page.

See also