Module:Top

აქ წარმოდგენილია მოდულის დოკუმენტაცია
ყურადღება: ეს მოდული შესაძლოა, ნაწილოვრივ ან სრულად დამალული იყოს.
იხილეთ Module:Top/doc, რათა შეცვალოთ ეს დოკუმენტაცია

გამოყენების ინსტრუქციები

{{#invoke:Top|main}}

მოდული გამოიყენება თარგებში:

• {{ზედა}}

---

-- <nowiki>

-------------------------------------------------------------------------------
--                              Module:Top
--
-- ამ მოდულით აისახება სიმბოლოები სტატიების გვერდების მარჯვენა კუთხეებში,
-- ისევე, როგორც კანონიკური და ლეგენდების ჩანართები იმ გვერდებზე, რომლებსაც აქვთ
-- პარალელური, მსგავსი სახელწოდების მქონე გვერდები, მონიშნული როგორც კანონი ან
-- ლეგენდები. მოდულს აგრეთვე თანდართული აქვს {{DISPLAYTITLE}}, რაც ნიშნავს, 
-- რომ თარგში "Top" პარამეტრ title-ის გამpოყენებით შეიძლება ნებისმიერი სათაურის
-- ასახვა, თუმცა, თუკი თავდაპირველი სახელწოდება შეიცავს ფრჩხილებში ჩასმულ დამატებით
-- ტექსტს, იგი თავად გვერდზე ამ შემთხვევაში აისახება შედარებით მცირე ზომის შრიფტით.
-------------------------------------------------------------------------------

local DEBUG_MODE = false -- თუ მითითებულია true, შეცდომები არ არის ასახული

-------------------------------------------------------------------------------
-- სიმბოლოების მონაცემები
-------------------------------------------------------------------------------

--[[
-- აქ ინახება მონაცემები ყველა სიმბოლოზე, რომელიც აისახება ზედა მარჯვენა კუთხეში.
-- დასაშვებია შემდეგი პარამეტრები:
-- * image - სიმბოლოს გამოსახულების სახელი, წინსართ "File:"-ის გარეშე (აუცილებელი პარამეტრი).
-- * tooltip - სიმბოლოს მინიშნება (არ არის აუცილებელი).
-- * link - გვერდი, რომელზეც გადავდივართ სიმბოლოზე დაწკაპუნებით (არ არის აუცილებელი).
-- * category - კატეგორია, რომელიც სიმბოლოს თანდართული აქვს, წინსართ "Category:"-ს გარეშე
--      (არ არის აუცილებელი).
-- * protectionAction - დაცვის აღმნიშვნელი სიმბოლოებისთვის - მაგალითად, იმ შემთხვევაში,
-- როდესაც სტატია დაცულია გადატანისგან ან ზოგადად, რედაქტირებისგან (არ არის აუცილებელი).
-- * protectionLevel - დაცვის დონე დაცვის სიმბოლოების შემთხვევაში.
--     მაგალითია "sysop". თუ გვერდს არ აქვს მითითებული დაცვის სწორი დონე,
--     იგი მოხვდება სპეციალურ კატეგორიაში და სიბბოლო არ აისახება  (არ არის აუცილებელი).
-- შენიშვნა: ეს არის მხოლოდ მონაცემთა შესანახი მოდული. ქვეცხრილებზე წვდომა შესაძლებელია 
-- მექანიკურად, ამიტომ ახალი ქვეცხრილების დამატებით ახალი სიმბოლოები არ დაემატება, ხოლო ქვეცხრილების
-- ამოშლა მოდულის მუშაობას შეაფერხებს.
--]]

local iconData = {
	can = {
		image = 'Top-canon.png',
		tooltip = 'ეს სტატია აღწერს თემას, რომელიც ითვლება კანონის ნაწილად.',
		link = 'კანონი'
	},
	leg = {
		image = 'Top-legends.png',
		tooltip = 'ეს სტატია აღწერს თემას, რომელიც შედის ვარსკვლავური ომების ლეგენდებში.',
		link = 'ვარსკვლავური ომების ლეგენდები'
	},
	ncc = {
		image = 'Top-NCC.png',
		tooltip = 'ეს სტატია აღწერს თემას, რომელიც არ ითვლება კანონის ნაწილად.',
		link = 'კანონი'
	},
	ncl = {
		image = 'Top-NCL.png',
		tooltip = 'ეს სტატია აღწერს თემას, რომელიც არ ითვლება კანონის ნაწილად ლეგენდების უწყვეტობაში.',
		link = 'ვარსკვლავური ომების ლეგენდები'
	},
	pre = {
		image = "Top-pre.png",
		tooltip = "ამ სტატიის თემა აღწერს რესპუბლიკის ჩამოყალიბებამდე მომხდარ მოვლენებს.",
		link = "რესპუბლიკის დაარსებამდე"
	},
	btr = {
		image = "Top-pre.png",
		tooltip = "ამ სტატიის თემა აღწერს რესპუბლიკამდე მომხდარ მოვლენებს.",
		link = "რესპუბლიკამდე"
	},
	old = {
		image = "Top-old.png",
		tooltip = "ამ სტატიის თემა აღწერს ძველი რესპუბლიკის დროს მომხდარ მოვლენებს.",
		link = "ძველი რესპუბლიკის ეპოქა (საგამომცემლო ეპოქა)"
	},
	imp = {
		image = "Top-imp.png",
		tooltip = "ამ სტატიის თემა აღწერს იმპერიის აღზევების ეპოქის დროს მომხდარ მოვლენებს.",
		link = "იმპერიის აღზევების ეპოქა"
	},
	reb = {
		image = "Top-reb.png",
		tooltip = "ამ სტატიის თემა აღწერს ამბოხების ეპოქის დროს მომხდარ მოვლენებს.",
		link = "ამბოხების ეპოქა"
	},
	new = {
		image = "Top-new.png",
		tooltip = "ამ სტატიის თემა აღწერს ახალი რესპუბლიკის ეპოქის დროს მომხდარ მოვლენებს.",
		link = "ახალი რესპუბლიკის ეპოქა (საგამომცემლო ეპოქა)"
	},
	njo = {
		image = "Top-njo.png",
		tooltip = "ამ სტატიის თემა აღწერს ჯედაების ახალი ორდენის ეპოქის დროს მომხდარ მოვლენებს.",
		link = "ჯედაების ახალი ორდენის ეპოქა (საგამომცემლო ეპოქა)"
	},
	lgc = {
		image = "Top-leg.png",
		tooltip = "ამ სტატიის თემა აღწერს მემკვიდრეობის ეპოქის დროს მომხდარ მოვლენებს.",
		link = "მემკვიდრეობის ეპოქა"
	},
	inf = {
		image = "Top-inf.png",
		tooltip = "ამ სტატიის თემა ითვლება ვარსკვლავური ომების უსასრულობების ნაწილად.",
		link = "უსასრულობები"
	},
	real = {
		image = "Top-real.png",
		tooltip = "ამ სტატიის თემა არსებობს ნამდვილ სამყაროში ან შეესაბამება მას.",
		link = "Category:სტატიები ნამდვილი სამყაროს შესახებ",
		category = "სტატიები ნამდვილი სამყაროს შესახებ"
	},
	audio = {
		image = "Youtube-top.png|20px",
		tooltip = "მოუსმინეთ ამ სტატიის აუდიოვარიანტს ინგლისურად ორიგინალური ვუკიპედიის YouTube-ის ოფიციალურ არხზე.",
		category = "სტატიები აუდიოვერსიებით"
	},
	fa = {
		image = "Top-FeaturedIcon.png",
		tooltip = "ეს არის ჰოლოპედიის რჩეული სტატია.",
		link = "ჰოლოპედია:რჩეული სტატიები",
		category = "ჰოლოპედიის რჩეული სტატიები"
	},
	ffa = {
		image = "Top-DefeaturedIcon.png",
		tooltip = "ეს არის ჰოლოპედიის ყოფილი რჩეული სტატია.",
		link = "ჰოლოპედია:რჩეული სტატიები",
		category = "ჰოლოპედიის ყოფილი რჩეული სტატიები"
	},
	ga = {
		image = "Top-GoodIcon.png",
		tooltip = "ეს არის ჰოლოპედიის კარგი სტატია.",
		link = "ჰოლოპედია:კარგი სტატიები",
		category = "ჰოლოპედია:კარგი სტატიები"
	},
	fga = {
		image = "Top-FormerGAicon.png",
		tooltip = "ეს არის ჰოლოპედიის კარგი სტატია.",
		link = "ჰოლოპედია:კარგი სტატიები",
		category = "ჰოლოპედიის კარგი სტატიები"
	},
	ca = {
		image = "Top-ComprehensiveArticle.png",
		tooltip = "ეს არის ჰოლოპედიის ვრცელი სტატია.",
		link = "ჰოლოპედია:ვრცელი სტატიები",
		category = "ჰოლოპედიის ვრცელი სტატიები"
	},
	fca = {
		image = "Top-FormerCAIcon.png",
		tooltip = "ეს არის ჰოლოპედიის ყოფილი ვრცელი სტატია.",
		link = "ჰოლოპედია:ვრცელი სტატიები",
		category = "ჰოლოპედიის ყოფილი ვრცელი სტატიები"
	},
	fprot = {
		protectionAction = "edit",
		protectionLevel = "sysop",
		image = "Top-Fprotect.png",
		tooltip = "ეს სტატია რედაქტირებისგან დაცულია.",
		link = "ჰოლოპედია:დაცვის_პოლიტიკა#სრული_დაცვა",
		category = "დაცული გვერდები"
	},
	sprot = {
		protectionAction = "edit",
		protectionLevel = "autoconfirmed",
		image = "Top-Sprotect.png",
		tooltip = "ეს სტატია რედაქტირებისგან ნაწილობრივ დაცულია.",
		link = "ჰოლოპედია:დაცვის_პოლიტიკა#ნაწილობრივ_დაცვა",
		category = "ნაწილობრივ დაცული გვერდები"
	},
	ssprot = {
		image = "Top-Ssprotect.png",
		tooltip = "ეს სტატია რედაქტირებისგან ნაწილობრივ დაცულია გაძლიერებული უსაფრთხოებით.",
		link = "ჰოლოპედია:დაცვის_პოლიტიკა#ნაწილობრივ_დაცვა_გაძლიერებული_უსაფრთხოებით",
		category = "გაძლიერებული უსაფრთხოებით ნაწილობრივ დაცული გვერდები"
	},
	mprot = {
		protectionAction = "move",
		protectionLevel = "sysop",
		image = "Top-Mprotect.png",
		tooltip = "ეს სტატია დაცულია გადატანისგან.",
		link = "ჰოლოპედია:დაცვის_პოლიტიკა#გადატანისგან_დაცვა",
		category = "გადატანისგან დაცული გვერდები"
	},
	uprot = {
		protectionAction = "upload",
		protectionLevel = "sysop",
		image = "Top-Uprotect.png",
		tooltip = "ეს ფაილი დაცულია ატვირთვისგან.",
		link = "ჰოლოპედია:დაცვის_პოლიტიკა#ატვირთვისგან_დაცვა",
		category = "ატვირთვისგან დაცული ფაილები"
	},
	noncanon = {
		image = "Top-inf.png",
		tooltip = "ამ სტატიის თემა ითვლება არაკანონიკურად."
	}
}

-------------------------------------------------------------------------------
-- დამხმარე ფუნქციები
-------------------------------------------------------------------------------

-- მითითებული გვერდის არსებობის შემოწმება. pcall გამოიყენება შეცდომების ასახვის მიზნით, თუკი
-- პარსერული ფუნქციების დასაშვებ რაოდენობას ვაჭარბებთ, ან სხვა შეცდომების შემთხვევაში.
-- ეს ფუნქცია ზრდის ყოველი ახალი გვერდის პარსერული ფუნქციების დასაშვებ რაოდენობას.
local function exists(page)
	local success, title = pcall(mw.title.new, page)
	return success and title and title.exists or false
end

-------------------------------------------------------------------------------
-- ეპოქების კლასი
-------------------------------------------------------------------------------

-- ეს კლასი ასრულებს მოდულის ყველა მნიშვნელოვან ფუნქციას. კლასი
-- გამოიყენება ჩვეულებრივი ფუნქციების სანაცვლოდ, რათა ავიცილოთ ყოველი ცალკეული
-- ფუნქციის მრავალი მნბიშვნელობა.

local Eras = {}
Eras.__index = Eras -- მემკვიდრეობის ჩართვა იმ ცხრილებისთვის, რომლებიც "Top" გამოიყენება როგორც მეტაცხრილი

-- ეს ფუნქცია ქმნის ახალი ეპოქების ობიექტს. აქ მიეთითება ყველა მნიშვნელობა არგუმენტებიდან
-- დa ხდება ნებისმიერი აუცილებელი წინასწარი დამუშავება.
function Eras.new(args, title)
	local obj = setmetatable({}, Eras) -- ობიექტის მემკვიდრეობით მიღება "Top"-იდან.
	obj.title = title or mw.title.getCurrentTitle()

	-- ობიექტის სტრუქტურის მითითება
	obj.categories = {}

	-- ასახული სახელწოდების პარამეტრების მითითება
	obj.noDisplayTitle = args.notitle
	obj.displayTitleBase = args.title
	obj.displayTitleParen = args.title2

	-- აუდიოვერსიის ბმული, თუკი ასეთი არსებობს
	obj.audio = args.audio

	-- დამალულის სტატუსის მითითება
	obj.isHidden = args.hide
	
	-- notoc-ის მითითება
	obj.hideToc = args.notoc

	-- კანონის და ლეგენდების სტატიების სახელწოდებების მითითება
	obj.legendsArticle = args.legends
	obj.canonArticle = args.canon
	
	if args.canon then
		obj.check = true
	end

	-- სიმბოლოების მონაცემების მიღება.
	do
		local icons = {}
		for _, v in ipairs(args) do
			local t = iconData[string.lower(v)]
			if t then
				icons[string.lower(v)] = t
			else
				-- მითითებული სიმბოლო სიმბოლოების მონაცემებში არ მოიპოვება, ამიტომ
				-- დაამატეთ კატეგორიის მიდევნების ნიშნული:
				obj.hasBadParameter = true
			end
		end
		if obj.audio then
			local t = iconData["audio"]
			t.link = obj.audio
			icons["audio"] = t
		end
		obj.icons = icons
	end

	return obj
end

-- შეცდომის ამოწევა. თუ DEBUG_MODE-ს მითითებული აქვს false, აქ წამოწეული შეცდომები
-- გადაეცემა გატანის ფუნქციას p._main.
function Eras:raiseError(msg)
	local level
	if DEBUG_MODE then
		level = nil
	else
		level = 0 -- მოდულის სახელწოდების და სტრიქონის ნომრის დახშობა შეცდომის შესახებ შეტყობინებაში.
	end
	error(msg, level)
end

-- კატეგორიის დამატება, თარგის გამოტანის ბოლოს ასახვისას.
function Eras:addCategory(cat, sort)
	table.insert(self.categories, {category = cat, sortKey = sort})
end

-- სომბოლოს მონაცემთა ქვეცხრილის მიღების მალხმობის მეთოდი.
function Eras:getIconData(code)
	return self.icons[code]
end

-- არის თუ არა ამჟამინდელ სახელწოდებაში ბოლოს ასახული /კანონი.
-- შენიშვნა: ქართულ ჰოლოპედიაში უნდა შევეცადოთ, რომ კანონიკურ
-- თემებთან დაკავშირებული სტატიების სახელწოდება არ შეიცავდეს ბოლოსართს /კანონი,
-- კანონიკურ თემებთან დაჯავშირებული სტატია ყოველთვის უნდა იყოს წარმოდგენილი 
-- ამ ბოლოსართის გარეშე. 
function Eras:hasCanonTitle()
	return self.title.text:find('/კანონი$')
end

-- არის თუ არა ამჟამინდელ სახელწოდებაში ბოლოს ასახული /ლეგენდები.
function Eras:hasLegendsTitle()
	return self.title.text:find('/ლეგენდები$')
end

-- ასახავს ლოგიკურ მნიშვნელობას, რომელიც ასახავს, არის თუ არა სიმბოლოები მითითებული
-- მომხმარებლის მიერ.
function Eras:hasAnyOfIcons(...)
	for i = 1, select('#', ...) do
		if self:getIconData(select(i, ...)) then
			return true
		end
	end
	return false
end	

-- აანალიზებს გვერდის სახელწოდებას და უთითებს {{DISPLAYTITLE}}-ს.
function Eras:renderDisplayTitle()
	local pagename = self.title.text

	-- გასვლა, თუკი არ უნდა მივუთითოთ სახელწოდება ან თუ ეს სახელწოდება
	-- იწყება მრგვალი ფრჩხილი.
	if self.noDisplayTitle or pagename:find('^%(') then
		return nil
	end

	-- ასახვის ბაზის და ასახვის მრგვალი ფრჩხილების მოძიება.
	local dBase = self.displayTitleBase
	local dParen = self.displayTitleParen
	if not dBase or not dParen then
		-- გვერდის ანალიზი, რათა მოვიძიოთ ძირითადი ნაწილი და დამაბოლოებელი მრგვალი ფრჩხილები.
		-- /კანონი ამოიშლება, ხოლო მრგვალი ფრჩხილები მიიღება მხოლოდ იმ შემთხვევაში, თუ ისინი
		-- გვერდის სახელწოდების ბოლოს არის მითითებული.
		local trimmedPagename = pagename:gsub('/კანონი$', '')
		trimmedPagename = trimmedPagename:gsub('/ლეგენდები$', '')
		local base, paren = trimmedPagename:match('^(.*)%s*%((.-)%)$')
		if not base then
			base = trimmedPagename
		end
		-- გამოვიყენოთ მოპოვებული მნიშვნელობები მხოლოდ იმ შემთხვევაში, თუ
		-- მნიშვნელობა უკვე არ არის მითითებული.
		dBase = dBase or base
		dParen = dParen or paren
	end

	-- ასახვის სტრიქონის შექმნა
	local display
	if dParen then
		display = string.format('%s <small>(%s)</small>', dBase, dParen)
	else
		display = dBase
	end
	if self.title.namespace ~= 0 then
		display = mw.site.namespaces[self.title.namespace].name .. ':' .. display
	end

	-- DISPLAYTITLE-ის გაფართოებული პარსერული ფუნქციის დაბრუნება.
	return mw.getCurrentFrame():preprocess(string.format(
		'{{DISPLAYTITLE:%s}}',
		display
	))
end

-- სიმბოლოთა მითითებული მონაცემებიდან ასახავს ეპოქის სიმბოლოს. მუშაობს პარამეტრებთან image,
-- tooltip, link და category, მაგრამ არა დაცვის ველებთან.
function Eras:renderIcon(data)
	-- კატეგორიის ბოლოს ასახვა, თუკი იგი არსებობს.
	if data.category then
		self:addCategory(data.category)
	end
	-- სიმბოლოს ასახვა და დაბრუნება.
	local ret = {}
	ret[#ret + 1] = '[[File:'
	ret[#ret + 1] = data.image
	if data.tooltip then
		ret[#ret + 1] = '|'
		ret[#ret + 1] = data.tooltip
	end
	if data.link then
		ret[#ret + 1] = '|link='
		ret[#ret + 1] = data.link
	end
	ret[#ret + 1] = ']]'
	return table.concat(ret)
end

-- ასახავს დაცვის სიმბოლოს მითითებული მონაცემების მიხედვით. თუკი გვერდს არ აქვს
-- დაცვის მითითებული დონე, აბრუნებს ნულს და ამატებს სიმბოლოს, რომელიც
-- დამუშავებისას მიდევნების კატეგორიას ამატებს.
function Eras:renderProtectionIcon(data)
	if not data.protectionAction then
		return self:renderIcon(data)
	end
	local protectionLevel = self.title.protectionLevels[data.protectionAction]
	protectionLevel = protectionLevel and protectionLevel[1]
	if protectionLevel and protectionLevel == data.protectionLevel then
		return self:renderIcon(data)
	else
		self.hasIncorrectProtectionIcon = true
	end
end

-- ასახავს პირველ სიმბოლოს, იქნება ეს კანონი თუ ლეგენდები, ან ნულს, თუკი უწყვეტობა დაუდგენელია
function Eras:renderContinuityIcon()
	if self.check then
		self:addCategory('სტატიების სხვადასხვა სათაურები')
	end

	-- ჯერ დავადგინოთ, თუ რომელ უწყვეტობას ვიყენებთ, თუკი ასეთი არსებობს.
	local continuity, isUsingCategory, nonCanon
	if self:hasAnyOfIcons('ncc', 'ncl') then
		nonCanon = true
	else
		nonCanon = false
	end
	if self:hasAnyOfIcons('leg', 'ncl') then
		continuity = 'legends'
		if not self:hasAnyOfIcons('real') then
			isUsingCategory = true
		end
	elseif self.title.namespace == 0 then
		if self:hasLegendsTitle() then
			continuity = 'legends'
			isUsingCategory = true
		elseif self:hasCanonTitle() then
			continuity = 'canon'
			isUsingCategory = true
		elseif self.legendsArticle then
			continuity = 'canon'
			isUsingCategory = true
		elseif self.canonArticle then
			continuity = 'legends'
			isUsingCategory = true
		elseif exists(self.title.text .. '/ლეგენდები') then
			continuity = 'canon'
			isUsingCategory = true
		elseif exists(self.title.text .. '/კანონი') then
			continuity = 'legends'
			isUsingCategory = true
		elseif self:hasAnyOfIcons('pre', 'btr', 'old', 'imp', 'reb', 'new',
			'njo', 'lgc')
		then
			continuity = 'legends'
			if self:hasAnyOfIcons('real') then
				isUsingCategory = false
			else
				isUsingCategory = true
			end
		elseif self:hasAnyOfIcons('inf', 'noncanon') then
			continuity = 'legends'
			isUsingCategory = false
		elseif self:hasAnyOfIcons('real') then
			if self:hasAnyOfIcons('can', 'ncc') then
				continuity = 'canon'
			end
			isUsingCategory = false
		else
			continuity = 'canon'
			isUsingCategory = true
		end
	end

	-- სიმბოლოების მონაცემთა გენერირება და სიმბოლოს შექმნა
	local data
	if continuity == 'canon' then
		if nonCanon then
			data = iconData['ncc']
			if isUsingCategory then
				data.category = 'სტატიები არაკანონიკურ საკითხებზე'
			end
		else
			data = iconData['can']
			if isUsingCategory then
				data.category = 'სტატიები კანონიკურ საკითხებზე'
			end
		end
		return self:renderIcon(data)
	elseif continuity == 'legends' then
		if nonCanon then
			data = iconData['ncl']
			if isUsingCategory then
				data.category = 'სტატიები ლეგენდების არაკანონიკურ საკითხებზე'
			end
		else
			data = iconData['leg']
			if isUsingCategory then
				data.category = 'სტატიები ლეგენდების საკითხებზე'
			end
		end
		return self:renderIcon(data)
	end
end

-- ასახავს სიმბოლოებს, რომლებიც გამოცემების ამა თუ იმ ეპოქას შეესაბამება.
function Eras:renderPublishingIcons()
	if not self:hasAnyOfIcons('can', 'ncc')
		and not self.legendsArticle
		and not self:hasCanonTitle()
	then
		local ret = {}
		local codes = {'pre', 'btr', 'old', 'imp', 'reb', 'new', 'njo', 'lgc', 'inf'}
		for _, code in ipairs(codes) do
			local data = self:getIconData(code)
			if data then
				ret[#ret + 1] = self:renderIcon(data)
			end
		end
		return table.concat(ret)
	end
end

-- ასახავს სხვა სიმბოლოებს, მაგალითად, რჩეული ან დაცვის სტატუსის მქონე სტატიაში.
function Eras:renderNonPublishingIcons()
	local ret = {}
	local codes = {'real', 'audio', 'fa', 'ffa', 'ga', 'fga', 'ca', 'fca'}
	for _, code in ipairs(codes) do
		local data = self:getIconData(code)
		if data then
			ret[#ret + 1] = self:renderIcon(data)
		end
	end
	local protectionCodes = {'fprot', 'sprot', 'ssprot', 'mprot', 'uprot'}
	for _, code in ipairs(protectionCodes) do
		local data = self:getIconData(code)
		if data then
			ret[#ret + 1] = self:renderProtectionIcon(data)
		end
	end
	return table.concat(ret)
end

-- ასახავს ყველა სიმბოლოს და აქცვეს მათ ტეგში div.
function Eras:renderIcons()
	local icons = {}
	icons[#icons + 1] = self:renderContinuityIcon()
	icons[#icons + 1] = self:renderPublishingIcons()
	icons[#icons + 1] = self:renderNonPublishingIcons()
	icons = table.concat(icons)

	local root = mw.html.create('div')
	root
		:attr('id', 'title-eraicons')
		:css('float', 'right')
		:css('position', 'static')
		:css('display', 'none')
		:wikitext(icons)

	return tostring(root)
end

-- ასახავს კანონის და ლეგენდების ჩანართებს სტატიებში, რომლებიც ორივე უწყვეტობაში არის მოქცეული.
function Eras:renderCanonTab()
	if self.isHidden or self.title.namespace ~= 0 then
		-- დასრულება, თუკი დამალულია ან არ არის სახელთა ძირითად სივრცეში.
		-- namespace.
		return nil
	end

	-- მოვიძიოთ გვერდის ტიპი, კანონიკური სახელწოდება და ლეგენდების სახელწოდება.
	local pageType, canonTitle, legendsTitle
	if self.legendsArticle then
		pageType = 'canon'
		canonTitle = self.title.text
		legendsTitle = self.legendsArticle
	elseif self.canonArticle then
		pageType = 'legends'
		canonTitle = self.canonArticle
		legendsTitle = self.title.text
	elseif self:hasCanonTitle() then
		pageType = 'canon'
		canonTitle = self.title.text
		legendsTitle = canonTitle:match('^(.*)/კანონი$') or canonTitle
	elseif self:hasLegendsTitle() then
		pageType = 'legends'
		legendsTitle = self.title.text
		canonTitle = legendsTitle:match('^(.*)/ლეგენდები$') or legendsTitle
	elseif exists(self.title.text .. '/ლეგენდები') then
		pageType = 'canon'
		legendsTitle = self.title.text .. '/ლეგენდები'
		canonTitle = self.title.text
	elseif exists(self.title.text .. '/კანონი') then
		pageType = 'legends'
		canonTitle = self.title.text .. '/კანონი'
		legendsTitle = self.title.text
	else
		-- ვერ ვადგენთ, აქვს თუ არა სტატიას ერთდროულად კანონიკური და ლეგენდების ვერსია,
		-- ამიტომ გავდივართ.
		return nil
	end
	
	if self:hasCanonTitle() then
		self:addCategory('სტატიები ქვესათაურში კანონის ქვეგვერდით')
	end

	-- კატეგორიების დამატება
	if pageType == 'canon' then
		self:addCategory('კანონიკური სტატიები ლეგენდების ანალოგებით')
	elseif pageType == 'legends' then
		self:addCategory('ლეგენდების სტატიები კანონიკური ანალოგებით')
	else
		self:addCategory('იზოლირებული სტატიები')
	end
	

	-- ცხრილის ძირეულის შექმნა
	local root = mw.html.create('table')
	root
		:attr('id', 'canontab')
		:css('text-align', 'center')
		:css('padding', '0')
		:css('margin', '0 0 5px 0')
		:css('border-left', '0')
		:css('border-right', '0')
		:css('border-top', '0')
		:css('border-bottom', '0')
		:css('border-spacing', '0')
		:css('border-collapse', 'collapse')
		:css('width', '100%')
		:css('vertical-align', 'top')

	local row = root:tag('tr')

	-- ამით იქმნება კანონის/ლეგენდების უჯრა. ფუნქციის სახით მისი აქ არსებობა, ჯაჭვის სანაცვლოდ,
	-- გვეხმარება იგივე კოდის ორჯერ ჩამატებისგან თავის არიდებაში.
	local function makeCell(id, color, image, link, tooltip)
		local cell = mw.html.create('td')
		cell
			:attr('id', id)
			:css('padding', '5px 0 5px 0')
			:css('background-color', color)
			:css('line-height', '0.95em')
			:css('font-size', '150%')
			:css('font-weight', 'bold')
			:css('min-width', '149px')
			:css('vertical-align', 'top')
			:css('border-radius', '5px 5px 0 0')
			:wikitext(string.format(
				' [[File:%s|link=%s|%s]]',
				image, link, tooltip
			))
		return cell
	end

	-- კანონის უჯრის შექმნა.
	do
		local link = canonTitle
		local color, image, tooltip
		if pageType == 'canon' then
			id = 'canontab-canon_ctcw'
			color = foregroundColor
			image = 'Tab-canon-white.png'
			tooltip = 'ეს სტატია აღწერს აღნიშნული თემის კანონიკურ ვერსიას.'
		else
			id = 'canontab-canon_ctcb'
			color = backgroundColor
			image = 'Tab-canon-black.png'
			tooltip = "დააწკაპუნეთ აქ, რათა მოხვდეთ ჰოლოპედიაში წარმოდგენილ თემის კანონიკურ ვერსიაზე."
		end
		row:node(makeCell(id, color, image, link, tooltip))
	end

	-- პირველი გამყოფი უჯრა
	row:tag('td')
		:attr('id', 'canontab-separator1')
		:css('width', '1px')
		:css('border-bottom', '0px')
		:wikitext('&nbsp;')
	
	-- ლეგენდების უჯრის შექმნა
	do
		local link = legendsTitle
		local color, image, tooltip
		if pageType ~= 'canon' then -- is a Legends page
			id = 'canontab-legends_ctlw'
			color = foregroundColor
			image = 'Tab-legends-white.png'
			tooltip = 'ეს სტატია აღწერს აღნიშნული თემის ლეგენდარულ ვერსიას.'
		else -- კანონის გვერდია
			id = 'canontab-legends_ctlb'
			color = backgroundColor
			image = 'Tab-legends-black.png'
			tooltip = "დააწკაპუნეთ აქ, რათა მოხვდეთ ჰოლოპედიაში წარმოდგენილ თემის ლეგენდების ვერსიაზე."
		end
		row:node(makeCell(id, color, image, link, tooltip))
	end
	
	-- მეორე გამყოფი უჯრა
	row:tag('td')
		:attr('id', 'canontab-separator2')
		:css('width', '3000px')
		:wikitext('&nbsp;')
	
	return tostring(root)
end

-- ყველა კატეგორიის ასახვა, რომლებიც მითითებულია Eras:addCategory-ს მეშვეობით ან კატეგორიის სიმბოლოებით.
function Eras:renderCategories()
	local fullPagename = self.title.prefixedText
	if fullPagename == 'Template:Eras' then
		-- გავდივართ, თუ შავ სიაში შეტანილ გვერდზე ვიმყოფებით.
		return nil
	end

	local pagename = self.title.text

	-- ასახავს ერთ კატეგორიას.
	local function renderCategory(cat, sort)
		return string.format(
			'[[%s:%s|%s]]', 'Category', cat, sort or pagename
		)
	end

	local ret = {}

	-- ასახავს კატეგორიებს ფუნქციიდან Eras:addCategory
	for i, t in ipairs(self.categories) do
		ret[i] = renderCategory(t.category, t.sortKey)
	end

	-- ასახავს კატეგორიებს კატეგორიების ნიშნულებიდან.
	if self.hasBadParameter then
		ret[#ret + 1] = renderCategory(
			'გვერდები ზედა თარგში არასწორი პარამეტრით'
		)
	end
	if self.hasIncorrectProtectionIcon then
		ret[#ret + 1] = renderCategory(
			'გვერდები დაცვის არასწორი სიმბოლოებით'
		)
	end

	return table.concat(ret)
end

-- დავამატოთ __NOTOC__, თუკი აუცილებელია
function Eras:renderNotoc()
	if self.hideToc then
		return '__NOTOC__'
	end
	return nil
end

-- ეს მეთოდი გამოიყენება იმ შემთხვევაში, როდესაც ფუნქცია tostring ზედას ობიექტში.
-- (მოქმედებს ზუსტად ისე, როგორც ფუნქცია Eras.__index.) იყენებს ზედა დონის ასახვის მოდელებს
-- და აბრუნებს საბოლოო შედეგს.
function Eras:__tostring()
	local ret = {}
	ret[#ret + 1] = self:renderDisplayTitle()
	ret[#ret + 1] = self:renderIcons()
	ret[#ret + 1] = self:renderCanonTab()
	ret[#ret + 1] = self:renderCategories()
	ret[#ret + 1] = self:renderNotoc()
	return table.concat(ret)
end

-------------------------------------------------------------------------------
-- გატანები
-------------------------------------------------------------------------------

local p = {}

-- ეს ფუნქცია არის შესვლის წერტილი Lua-ზე დაფუძნებული სხვა მეთოდებიდან.
function p._main(args)
	-- მივუთითოთ ფუნქცია pcall-იდან, რათა თავი მოვუყაროთ შეცდომებს
	-- და ვუჩვენოთ ისინი მომხმარებელს, ბუნდოვანი "სკრიპტის შეცდომის" სანაცვლოდ.
	-- (სინამდვილეში, იგი არ არის ბუნდოვანი. შეცდომაზე დაწკაპუნებით აისახება,
	-- თუ რა არის პრობლემა, მაგრამ ბევრმა მომხმარებელმა ამის შესახებ არ იცის.)
	local function getErasResult ()
		local erasObj = Eras.new(args)
		-- დროებითი მეთოდი, რომელიც შეცდომას მალავს Lego-სთან დაკავშირებულ სტატიებში
		if erasObj == false then
			return '[[' .. 'Category:გვერდები ზედა თარგში არასწორი პარამეტრებით]]'
		end
		return tostring(erasObj)
	end

	-- შედეგის მიღება. შეცდომებს თვს ვუყრით, თუკი გამართვის რეჟიმის მნიშვნელობა მითითებულია როგორც false.
	local success, result
	if DEBUG_MODE then
		success = true
		result = getErasResult()
	else
		success, result = pcall(getErasResult)
	end

	-- შედეგის დაბრუნება, თუკი არ არის შეცდომები, ხოლო შეცდომის შესახებ ფორმატირებული შეტყობინების
	-- - თუკი არის.
	if success then
		return result
	else
		return string.format(
			'<strong class="error">შეცდომა [[Template:ზედა]]: %s.</strong>' ..
			'[[' .. 'Category:გვერდები ზედა თარგში არასწორი პარამეტრით]]',
			result -- ეს არის შეტყობინება შეცდომის შესახებ
		)
	end
end

-- ეს არის ვიკიტექსტიდან ხელმისაწვდომი ფუნქცია. მასზე წვდომა შესაძლებელია თარგიდან
-- თარგში გამოძახებული ფუნქციების სახით შეიძლება ჩაისვას მხოლოდ ტექსტი "{{#invoke:Top|main}}"
-- და, თარგის ნებისმიერი გამოყენების დროს, ნებისმიერი არგუმენტი, რომელიც მას მიმართავს, მოდულით მუშავდება.
function p.main(frame)
	local args = {}
	for k, v in pairs(frame:getParent().args) do
		v = v:match('^%s*(.-)%s*$') -- ცარიელი სივრცის მოცილება
		if v ~= '' then
			args[k] = v
		end
	end
	return p._main(args)
end

return p

-- </nowiki>
-- [[Category:ეპოქების გამოყენების თარგები|{{PAGENAME}}]]