Modul:Category handler: razlika između inačica

Izvor: Hrvatska internetska enciklopedija
Prijeđi na navigaciju Prijeđi na pretraživanje
Stvorena nova stranica sa sadržajem: »-------------------------------------------------------------------------------- --...«.
 
mNema sažetka uređivanja
 
Redak 1: Redak 1:
--------------------------------------------------------------------------------
-- Srednja verzija Category handlera za enciklopedija.cc
--                                                                            --
-- Minimalno potrebna logika, kompatibilna s enwiki predlošcima
--                              CATEGORY HANDLER                              --
-- Uklonjeni: demopage, category2, wrappers, fallback, subpage logika
--                                                                            --
--     This module implements the {{category handler}} template in Lua,     --
--     with a few improvements: all namespaces and all namespace aliases    --
--      are supported, and namespace names are detected automatically for    --
--      the local wiki. This module requires [[Module:Namespace detect]]      --
--      and [[Module:Yesno]] to be available on the local wiki. It can be    --
--      configured for different wikis by altering the values in              --
--      [[Module:Category handler/config]], and pages can be blacklisted      --
--      from categorisation by using [[Module:Category handler/blacklist]].  --
--                                                                            --
--------------------------------------------------------------------------------


-- Load required modules
local p = {}
local yesno = require('Module:Yesno')
local yesno = require('Module:Yesno')
local shared = require('Module:Category handler/shared')
local data = require('Module:Category handler/data')
local blacklist = require('Module:Category handler/blacklist')


-- Lazily load things we don't always need
-------------------------------------------------------------------------------
local mShared, mappings
-- Glavna funkcija
 
-------------------------------------------------------------------------------
local p = {}
 
--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------
 
local function trimWhitespace(s, removeBlanks)
if type(s) ~= 'string' then
return s
end
s = s:match('^%s*(.-)%s*$')
if removeBlanks then
if s ~= '' then
return s
else
return nil
end
else
return s
end
end
 
--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------
 
local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler
 
function CategoryHandler.new(data, args)
local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)
-- Set the title object
do
local pagename = obj:parameter('demopage')
local success, titleObj
if pagename then
success, titleObj = pcall(mw.title.new, pagename)
end
if success and titleObj then
obj.title = titleObj
if titleObj == mw.title.getCurrentTitle() then
obj._usesCurrentTitle = true
end
else
obj.title = mw.title.getCurrentTitle()
obj._usesCurrentTitle = true
end
end
 
-- Set suppression parameter values
for _, key in ipairs{'nocat', 'categories'} do
local value = obj:parameter(key)
value = trimWhitespace(value, true)
obj['_' .. key] = yesno(value)
end
do
local subpage = obj:parameter('subpage')
local category2 = obj:parameter('category2')
if type(subpage) == 'string' then
subpage = mw.ustring.lower(subpage)
end
if type(category2) == 'string' then
subpage = mw.ustring.lower(category2)
end
obj._subpage = trimWhitespace(subpage, true)
obj._category2 = trimWhitespace(category2) -- don't remove blank values
end
return obj
end
 
function CategoryHandler:parameter(key)
local parameterNames = self._data.parameters[key]
local pntype = type(parameterNames)
if pntype == 'string' or pntype == 'number' then
return self._args[parameterNames]
elseif pntype == 'table' then
for _, name in ipairs(parameterNames) do
local value = self._args[name]
if value ~= nil then
return value
end
end
return nil
else
error(string.format(
'invalid config key "%s"',
tostring(key)
), 2)
end
end


function CategoryHandler:isSuppressedByArguments()
function p.main(frame)
return
    local args = frame:getParent().args
-- See if a category suppression argument has been set.
    local namespace = mw.title.getCurrentTitle().namespace
self._nocat == true
or self._categories == false
or (
self._category2
and self._category2 ~= self._data.category2Yes
and self._category2 ~= self._data.category2Negative
)


-- Check whether we are on a subpage, and see if categories are
    -- Ako je stranica na blacklisti → ne kategoriziraj
-- suppressed based on our subpage status.
    if blacklist[namespace] then
or self._subpage == self._data.subpageNo and self.title.isSubpage
        return ''
or self._subpage == self._data.subpageOnly and not self.title.isSubpage
    end
end


function CategoryHandler:shouldSkipBlacklistCheck()
    -- Ako je korisnik stavio nocat=yes → ne kategoriziraj
-- Check whether the category suppression arguments indicate we
    if yesno(args.nocat) then
-- should skip the blacklist check.
        return ''
return self._nocat == false
    end
or self._categories == true
or self._category2 == self._data.category2Yes
end


function CategoryHandler:matchesBlacklist()
    -- Ako je korisnik stavio categories=no → ne kategoriziraj
if self._usesCurrentTitle then
    if args.categories == 'no' then
return self._data.currentTitleMatchesBlacklist
        return ''
else
    end
mShared = mShared or require('Module:Category handler/shared')
return mShared.matchesBlacklist(
self.title.prefixedText,
mw.loadData('Module:Category handler/blacklist')
)
end
end


function CategoryHandler:isSuppressed()
    -- Odredi vrstu kategorije prema namespaceu
-- Find if categories are suppressed by either the arguments or by
    local map = data.mappings or {}
-- matching the blacklist.
    local key = map[namespace] or map.other
return self:isSuppressedByArguments()
or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end


function CategoryHandler:getNamespaceParameters()
    if not key then
if self._usesCurrentTitle then
        return ''
return self._data.currentTitleNamespaceParameters
    end
else
if not mappings then
mShared = mShared or require('Module:Category handler/shared')
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
end
return mShared.getNamespaceParameters(
self.title,
mappings
)
end
end


function CategoryHandler:namespaceParametersExist()
    -- Ako je korisnik ručno postavio parametar (npr. |yes=Kategorija:X)
-- Find whether any namespace parameters have been specified.
    local manual = args[key]
-- We use the order "all" --> namespace params --> "other" as this is what
    if manual and manual ~= '' then
-- the old template did.
        return string.format('[[Category:%s]]', manual)
if self:parameter('all') then
    end
return true
end
if not mappings then
mShared = mShared or require('Module:Category handler/shared')
mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
end
for ns, params in pairs(mappings) do
for i, param in ipairs(params) do
if self._args[param] then
return true
end
end
end
if self:parameter('other') then
return true
end
return false
end
 
function CategoryHandler:getCategories()
local params = self:getNamespaceParameters()
local nsCategory
for i, param in ipairs(params) do
local value = self._args[param]
if value ~= nil then
nsCategory = value
break
end
end
if nsCategory ~= nil or self:namespaceParametersExist() then
-- Namespace parameters exist - advanced usage.
if nsCategory == nil then
nsCategory = self:parameter('other')
end
local ret = {self:parameter('all')}
local numParam = tonumber(nsCategory)
if numParam and numParam >= 1 and math.floor(numParam) == numParam then
-- nsCategory is an integer
ret[#ret + 1] = self._args[numParam]
else
ret[#ret + 1] = nsCategory
end
if #ret < 1 then
return nil
else
return table.concat(ret)
end
elseif self._data.defaultNamespaces[self.title.namespace] then
-- Namespace parameters don't exist, simple usage.
return self._args[1]
end
return nil
end
 
--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------
 
local p = {}


function p._exportClasses()
    -- Ako postoji "all" parametar → uvijek dodaj
-- Used for testing purposes.
    if args.all and args.all ~= '' then
return {
        return string.format('[[Category:%s]]', args.all)
CategoryHandler = CategoryHandler
    end
}
end


function p._main(args, data)
    -- Ako postoji "other" parametar → koristi ga
data = data or mw.loadData('Module:Category handler/data')
    if args.other and args.other ~= '' then
local handler = CategoryHandler.new(data, args)
        return string.format('[[Category:%s]]', args.other)
if handler:isSuppressed() then
    end
return nil
end
return handler:getCategories()
end


function p.main(frame, data)
    -- Ako ništa nije zadano → ne kategoriziraj
data = data or mw.loadData('Module:Category handler/data')
    return ''
local args = require('Module:Arguments').getArgs(frame, {
wrappers = data.wrappers,
valueFunc = function (k, v)
v = trimWhitespace(v)
if type(k) == 'number' then
if v ~= '' then
return v
else
return nil
end
else
return v
end
end
})
return p._main(args, data)
end
end


return p
return p

Posljednja izmjena od 27. lipanj 2026. u 11:32

Dokumentacija modula
prikaži • uredi • povijest • osvježi
Modul sadrži implementaciju predloška {{Category handler}}.

Ova će dokumentacija pojasniti kako koristiti modul u drugim modulima. Za korištenje u predlošcima, molim pogledajte dokumentaciju istoimenog predloška.

Korištenje iz drugih Lua modula

Kad ne koristiti ovaj modul

Ako modul treba kategorizirati samo jednu vrstu sadržaja (npr. samo datoteke, ili samo predloške), nije poželjno koristiti ovaj modul. Takvu kategorizaciju moguće je napraviti sljedećim kodom: <syntaxhighlight lang="lua"> local title = mw.title.getCurrentTitle() -- dohvati naslov stranice if title.nsText == 'Datoteka' then -- ako je imenski prostor naslova jednak 

   -- uradi nešto

end </syntaxhighlight>

Ako trebate zasebno kategorizirati različite vrste sadržaja, poželjno je koristiti ovaj modul.

Imenski prostori

Modul radi s imenima imenskih prostora na HIE.

glavni - glavni imenski prostor
razgovor - sve razgovorne stranice (razgovor sa suradnikom, razgovor o predlošku, ...)
datoteka, Hrvatska internetska enciklopedija, suradnik - imena ostalih imenskih prostora. Pogledajte tablicu niže za puni popis
other - svi ostali imenski prostori koji nisu poimence navedeni

Popis imenskih prostora

(bez prostora razgovor i other)
Name Namespaces
draft talk 119
education program 446
mediawiki talk 9
wikipedia talk 5
other
help 12
category 14
module talk 829
user talk 3
help talk 13
module 828
file talk 7
book talk 109
template 10
user 2
template talk 11
wikipedia 4
education program talk 447
book 108
talk 1, 3, 5, 7, 9, 11, 13, 15, 101, 109, 119, 447, 829
portal talk 101
main 0
draft 118
portal 100
file 6
mediawiki 8
category talk 15

Primjeri korištenja

Modul prima dva ili više parametara.

Općeniti primjer

Niže je primjer korištenja: <syntaxhighlight lang="lua"> p = {} local categoryHandler = require('Module:Category handler').main

function p.main( frame ) 

   local rezultat = 'Ovaj je modul namijenjen za GIP i razgovore.'
   local kategorija = categoryHandler{
       glavni   = , -- Kategorizacija u GIP-u
       razgovor = , -- Kategorizacija u razgovorima
       other    = , -- Kategorizacija u ostalim imenskim prostorima
       nocat    = frame.args.nocat                   -- kako bi "nocat=true/false" radilo
   }
   kategorija = kategorija or    -- izbjegava grješku ako kategorija nije zadana
   return rezultat .. kategorija

end

return p </syntaxhighlight> Pojašnjenje koda:

Uzmimo da je primjer iznad dio modula Foo. Modul Foo možemo dodati u predložak ili pojedinačne stranice pisanjem {{#invoke:foo|main}}.
Zbog gornjeg koda predložak ili stranice s tim modulom svrstavat će se u kategoriju Kategorija:Neka kategorija1 ako su u GIP-u, u kategoriju Kategorija:Neka kategorija2 ako su na kakvoj razgovornoj stranici ili u kategoriju Kategorija:Neka kategorija3 ako se nalaze negdje drugdje.
U pojedinačni poziv predloška ili modula možemo staviti |nocat=true da se gornji vid kategorizacije ne provodi zasebno za svaki predložak ili modul.

Ista kategorija za više imenskih prostora

Ako trebamo više različitih imenskih prostora svrstati u istu kategoriju, činimo to ovako: <syntaxhighlight lang="lua"> p = {} local categoryHandler = require('Module:Category handler').main

function p.main( frame ) 

   local rezultat = 'Ovaj je modul namijenjen za GIP i razgovore.'
   local kategorija = categoryHandler{
       glavni   = , -- Kategorizacija u GIP-u
       [1]      = , -- prvi neimenovani parametar dodjeljujemo kategoriji
       pomoć    = 1,        -- imenski prostor pomoći...
       suradnik = 1,        -- i imenski prostor suradnika smještaju se u kategoriju navedenu pod [1]
       razgovor    = ,    -- bez kategorije na razgovornim stranicama
       nocat    = frame.args.nocat    -- kako bi "nocat=true/false" radilo
   }
   kategorija = kategorija or    -- izbjegava grešku ako kategorija nije zadana
   return rezultat .. kategorija

end

return p

</syntaxhighlight>

-- Srednja verzija Category handlera za enciklopedija.cc
-- Minimalno potrebna logika, kompatibilna s enwiki predlošcima
-- Uklonjeni: demopage, category2, wrappers, fallback, subpage logika

local p = {}
local yesno = require('Module:Yesno')
local shared = require('Module:Category handler/shared')
local data = require('Module:Category handler/data')
local blacklist = require('Module:Category handler/blacklist')

-------------------------------------------------------------------------------
-- Glavna funkcija
-------------------------------------------------------------------------------

function p.main(frame)
    local args = frame:getParent().args
    local namespace = mw.title.getCurrentTitle().namespace

    -- Ako je stranica na blacklisti → ne kategoriziraj
    if blacklist[namespace] then
        return ''
    end

    -- Ako je korisnik stavio nocat=yes → ne kategoriziraj
    if yesno(args.nocat) then
        return ''
    end

    -- Ako je korisnik stavio categories=no → ne kategoriziraj
    if args.categories == 'no' then
        return ''
    end

    -- Odredi vrstu kategorije prema namespaceu
    local map = data.mappings or {}
    local key = map[namespace] or map.other

    if not key then
        return ''
    end

    -- Ako je korisnik ručno postavio parametar (npr. |yes=Kategorija:X)
    local manual = args[key]
    if manual and manual ~= '' then
        return string.format('[[Category:%s]]', manual)
    end

    -- Ako postoji "all" parametar → uvijek dodaj
    if args.all and args.all ~= '' then
        return string.format('[[Category:%s]]', args.all)
    end

    -- Ako postoji "other" parametar → koristi ga
    if args.other and args.other ~= '' then
        return string.format('[[Category:%s]]', args.other)
    end

    -- Ako ništa nije zadano → ne kategoriziraj
    return ''
end

return p
Dobavljeno iz "https://enciklopedija.cc/index.php?title=Modul:Category_handler&oldid=787317"