Modül:Kategori/test

Modül belgelemesi[gör] [değiştir] [geçmiş] [temizle]

Yukarıdaki belgeleme içeriği Modül:Kategori/belge sayfasından yansıtılmaktadır. (değiştir | geçmiş)
Kullanıcılar denemelerini bu şablonun deneme tahtası (oluştur | yansıtma) ve test senaryosu (değiştir) sayfalarında yapabilirler.
Lütfen kategorileri /belge alt sayfasına ekleyin. Bu modül ile ilgili alt sayfalar için buraya tıklayınız.

--Genel veriler

local degerler = {"kurulan", "feshedilen", "feshedilmiş", "kapanan", "kapatılan", "varlığı sona eren",
	"başlayan", "sona eren", "tamamlanan", "tamamlanmış", "tanıtılan", "tanıtılmış", "tanımlanan",
	"oluşturulan", "doğan", "doğumlu", "ölen", "keşfedilen", "fırlatılan", "geçen", "yapan"
}

--lazım olabilecek kademe listesi
local kademeler = {"yıl", "onyıl", "yüzyıl", "binyıl"}

--bu fonksiyon girilen bir yazıda birinci değeri bulup
--onu ikinci değer ile değiştirmeye yarar
local function bulvedeg(yazi, bir, iki)
	return mw.ustring.sub(mw.ustring.gsub(yazi, bir, iki), 1, -1)
end

--yerelde kod kısaltmak için
local bul = mw.ustring.find

--zaman modülü
local zaman = require("Modül:Zaman")
local function yilBul(p1, p2) return zaman.YIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "2020'ler" gibi olur
local function onYil(p1, p2) return zaman.ONYIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "21. yüzyıl" gibi olur
local function yuzYil(p1, p2) return zaman.YUZYIL({args={p1, p2}}) end
-- bu fonksiyonun sonucu "3. binyıl" gibi olur
local function binYil(p1, p2) return zaman.BINYIL({args={p1, p2, "yüzyıl"}}) end

-- tipe göre ikinci tablodaki değerleri verir
local function tipeGorePar(tip, tab)
	if tip == "yıl" then return tab[1]
	elseif tip == "onyıl" then return tab[2]
	elseif tip == "yüzyıl" then return tab[3]
	elseif tip == "binyıl" then return tab[4] end
end

---*---*---*---*---*---*---*---*---*---*---*---*---
-- kategori nesnesini ilgilendiren
-- fonksiyon ve tablolar
---*---*---*---*---*---*---*---*---*---*---*---*---
local Kategori = {}


function Kategori:getirAsilAd(kademe)
	return tipeGorePar((kademe and kademe or self._tip), self._rawData) or self._asilAd
end


function Kategori:getirKategoriAdi(goreTipi)
	local yil = self:getirYil()
	local ad = self:getirAsilAd()
	
	local function mevcutMu(yil, ad)
		-- yıl ifadesinden önce gelen bir ifade mevcut mu?
		if self:basta() then
			if type(self:basta()) == "table" then
				ad = bulvedeg(ad, tipeGorePar(self._tip, self:basta()), "")
				yil = tipeGorePar(self._tip, self:basta()) .. " " .. yil
			else
				ad = bulvedeg(ad, self:basta(), "")
				yil = self:basta() .. " " .. yil
			end
		end
		
		local d1, d2 = yil, ad
		return mw.title.new('Kategori:' .. d1 .. d2).exists and d1 .. d2 or d1 .. " " .. d2
	end
	
	local k = type(self._rawData.ek) == "table"
	local yEk = k and self._rawData.ek[1] or self._rawData.ek
	local oEk = k and self._rawData.ek[2] or yEk
	local uEk = k and self._rawData.ek[3] or oEk
	local bEk = k and self._rawData.ek[4] or uEk

	local ek = tipeGorePar(self:getirTip(), {yEk, oEk, uEk, bEk})
	
	-- göre kategorileri için
	if self:getirTip() == "göre" and not bul(self._yil, "%d") then
		local son
		local ust = self:sonHarfSil()
		local gore = self:gore()
		
		if goreTipi then
			local hey = goreTipi .. " göre " .. self:sonHarfSil()
			if mw.title.new("Kategori:" .. tipHallet(hey, self._yil)).exists
			and not mw.title.new("Kategori:" .. tipHallet(hey, self._yil)).isRedirect then
				ust = hey
			end
		end

		if self._yil == "dönem" and self:gore() == "üst" then
			son = ust
		else
			local normal = tipHallet(ust, self._yil)
			if self._yil == "dönem" then
				son = (type(gore) == "string" and gore ~= "hayır") and self:gore() or normal
				son = type(self:gore()) == "table" and self:gore()[2] or normal
			else
				son = normal
			end
		end
		return son
	elseif yil then
		if ek and ek ~= "d" and ek ~= "y" then
			if ek == "ki" then
				return mevcutMu(yilEki(yil)..ek, ad)
			else
				return mevcutMu(yil..ek, ad)
			end
		elseif ek and ek == "d" then
			return mevcutMu(yilEki(yil), ad)
		else
			return mevcutMu(yil, ad)
		end
	else
		return ad
	end
end


function Kategori:getirCubukAdi()
	return tipeGorePar(self._tip, {
		yilBul(self._yil), self._yil,
		bulvedeg(self._yil, "yüzyıl", "yy"), bulvedeg(self._yil, "binyıl", "by")
	})
end


function Kategori:getirYil()
	return tipeGorePar(self._tip, {
		yilBul(self._yil), onYil(self._yil),
		yilBul(self._yil)..". yüzyıl", yilBul(self._yil)..". binyıl"
	})
end


function Kategori:gore()
	return self._rawData.gore
end


function Kategori:goreSon()
	return self._rawData.goreSon
end


function Kategori:goreTipi()
	return self._rawData.goreTipi
end


function Kategori:basta()
	return self._rawData.basta
end


function Kategori:donustur()
	return self._rawData.donustur
end


function Kategori:kademe()
	return self._rawData.kademe
end


function Kategori:kademeYok()
	local kademeyiSil
	local tip = self._tip
	local kademeYok = self._rawData.kademeYok
	
	if kademeYok then
		if kademeYok == 3 then
			if tip == "yıl" or tip == "onyıl" or tip == "yüzyıl" then
				kademeyiSil = true
			end
		elseif kademeYok == 2 then
			if tip == "yıl" or tip == "onyıl" then
				kademeyiSil = true
			end
		elseif kademeYok == 1 then
			if tip == "yıl" then
				kademeyiSil = true
			end
		end
	end
	
	return kademeyiSil
end


function Kategori:getirOncesi()
	if self._rawData.oncesi then
		local oncesi = self._rawData.oncesi
		
		local karsilastir = tipeGorePar(self._tip, {
			oncesi[1],
			bulvedeg(bulvedeg(onYil(oncesi[1]), "'l[ae]r", ""), "MÖ ", "-"),
			bulvedeg(bulvedeg(yuzYil(oncesi[1]), ". yüzyıl", ""), "MÖ ", "-"),
			bulvedeg(bulvedeg(binYil(oncesi[1]), ". binyıl", ""), "MÖ ", "-")
		})
		
		if tonumber(self._yil) < tonumber(karsilastir) then
			return getirAsilAdaGore(oncesi[2], self._yil, self._tip)
		else
			return nil
		end
	else
		return nil
	end
end


function Kategori:getirUstYil()
	return tipeGorePar(self._tip, {
		onYil(self._yil), yuzYil(self._yil), binYil(self._yil)
	})
end


function Kategori:getirVikiveri()
	return mw.wikibase.getEntity(mw.wikibase.getEntityIdForCurrentPage())
end


function Kategori:sonHarfSil(kademe)
	local shs = self._rawData.sonHarfSil
	local shs2 = self._rawData.sonIkiHarfSil
	local asilAd = self:getirAsilAd(kademe or nil)
	
	if type(shs) == "table" then
		shs = tipeGorePar((kademe and kademe or self._tip), shs)
	end
	if shs == true or shs2 == true then
		asilAd = mw.ustring.sub(asilAd, 1, (shs2 and -3 or -2))
	end
	
	return asilAd
end


function Kategori:getirEbeveynler()
	local ebeveynler = {}

	--ebeveynlerin listesi
	islem = self._rawData.ebeveynler or {}
	local tip = self._tip

	--her ebeveynimizi nesneye dönüştürüyoruz
	for _,ebeveyn in ipairs(islem) do
		--normalde ana dizinimiz kategoriler'dir, fakat "göre" tipli kategorilerde
		if ebeveyn == "kategoriler" and tip ~= "göre" then ebeveyn = "" end
		--bu ebeveynlerin birer döneme göre ... kategorisi mevcut değildir
		if ebeveyn == "yıllar" or ebeveyn == "onyıllar" or ebeveyn == "yüzyıllar" or ebeveyn == "binyıllar" then tip = "üst" end
		--eğer kategorinin ebeveynlerinden birisi normal
		--yıl kategorilerinde farklı isme, ama göre kategorilerinde
		--farklı isme sahipse bunu ayırt edelim
		local ebNesne = getirAsilAdaGore(ebeveyn, self._yil, tip)
		if tip == "göre" and ebNesne:donustur() and self:getirAsilAd() ~= ebNesne:donustur() then
			table.insert(ebeveynler, getirAsilAdaGore(ebNesne:donustur(), self._yil, tip))
		end
		--burada da kademezi yıldan değil de daha yukarıdan başlayan kategoriler için
		--"[YIL] kişileri" ve "[ONYIL] kişileri" kategorilerinin oluşmasından kaçınıyoruz
		if ebNesne:kademeYok()
		or (tip == "göre" and ebNesne:donustur() and self:getirAsilAd() ~= ebNesne:donustur()) then else
			if ebNesne:getirOncesi() then
				table.insert(ebeveynler, ebNesne:getirOncesi())
			else
				table.insert(ebeveynler, ebNesne)
			end
		end
	end
	
	--[[
		ebeveynleri çağırırken, her birini yeni bir kategori nesnesi olarak çağıracağız,
		fakat, normal ebeveyn nesnelerinin dışında her bir kategorinin kendisine ait
		bir üst kategorisi vardır; mesela 2010'da eserler'in üst kategorisi: 2010'larda eserler
		onun da bir üstü 21. yüzyılda eserler; bu üst kategorilerin var olup olmadığını
		kontrol etmek gerekiyor
	--]]
	if self:getirUstTip() then
		table.insert(ebeveynler, getirAsilAdaGore(self:getirAsilAd(), self:getirUstYil(), self:getirUstTip()))
	end

	--[[
		işte burası eğer ebeveynlerde bir "göre" kategorisi yoksa
		otomatik "Yıla göre .." veya "Yüzyıla göre .." düzeninde
		kategoriler ekleniyor
		
		eğer self:sonHarfSil() fonksiyonunu kullanıyorsa bir nesne,
		bunun "Yıla göre .." kategorisi eklenirken en sondan bir harfi silinir
		sebebi de, mesela "2010 kişileri" kategorisini "Yıla göre kişileri"
		değil de "Yıla göre kişiler" yapmalıyız, bu tarz kategorilerde "sonHarfSil"
		değeri mevcuttur, bu da bu işlemin yapılmasına olanak sağlar
	--]]
	local katAd = self:sonHarfSil()
	if katAd ~= "" and tip ~= "göre" then
		if bul(katAd, "göre") and not self:basta() then
			table.insert(ebeveynler, getirAsilAdaGore(tip.."a ve "..katAd, self._yil, self._tip))
		else
			table.insert(ebeveynler, getirAsilAdaGore(tipHallet(katAd, tip), self._yil, self._tip))
		end
	end
	
	--tüm nesnelerin çıktısı
	return ebeveynler or {}
end


function Kategori:getirBak()
	local bak = self._rawData.bak or {}
	local son = {}
	
	if self._tip == "göre" then
		for _,b in ipairs(bak) do
			local baslik = mw.getContentLanguage():ucfirst(tipHallet(b, self._yil))
			if mw.title.new("Kategori:"..baslik).exists then table.insert(son, baslik) end
		end
	else
		for _,b in ipairs(bak) do
			local baslik = getirAsilAdaGore(b, self._yil, self._tip):getirKategoriAdi()
			if mw.title.new("Kategori:"..baslik).exists then table.insert(son, baslik) end
		end
	end
	
	return son
end


function Kategori:getirAciklama()
	if self._rawData.aciklama then
		return mw.getContentLanguage():ucfirst(parametreleriHallet(self._rawData.aciklama, self:getirYil(), self:getirTip(), self._yil))
	elseif bul(mw.title.getCurrentTitle().text, "^MÖ") then
		return "Bu kategori "..mw.title.getCurrentTitle().text.." içindir."
	else
		return "Bu kategori "..mw.getContentLanguage():lcfirst(mw.title.getCurrentTitle().text).." içindir."
	end
end


function Kategori:getirTip()
	return self._tip
end


function Kategori:getirUstTip()
	if self._tip == "yıl" and self._rawData.kademe and self._rawData.kademe > 1 then
		return "onyıl"
	elseif self._tip == "onyıl" and self._rawData.kademe and self._rawData.kademe > 2 then
		return "yüzyıl"
	elseif self._tip == "yüzyıl" and self._rawData.kademe and self._rawData.kademe > 3 then
		return "binyıl"
	end
end


function Kategori:getirVeriModulu()
	return self._modul
end


function Kategori:getirSiraAnahtari()
	local zincir = {}
	local siraAnahtarlari = {}
	
	--buradaki seviyeler tablosu aynı ebeveynlerde olduğu
	--gibi onlarla eşleşecek şekilde çalışıyor
	local anahtarlar = {["yıl"]="YSON", ["onyıl"]="YSONİKİ", ["yüzyıl"]="DORTLU", ["binyıl"]="DORTLU"}
	
	for s,a in ipairs(self._rawData.sira_anahtari or {}) do
		table.insert(zincir, a)
	end
	
	if self:getirUstTip() then
		table.insert(zincir, anahtarlar[self._tip])
	end
	
	for i, ebeveyn in ipairs(self._rawData.ebeveynler or {}) do
		local ebNesne = getirAsilAdaGore(ebeveyn, self._yil, self._tip)
		if ebNesne:kademeYok() then
			table.remove(zincir, i)
		end
	end
	
	table.insert(zincir, "DORTLU")

	for _,anahtar in ipairs(zincir) do
		if anahtar == "YSON" then anahtar = mw.ustring.sub( self._yil, -1 )
		elseif anahtar == "YSON-1" then anahtar = mw.ustring.sub( tostring(tonumber(self._yil)-1), -1 )
		elseif anahtar == "YSONİKİ" then anahtar = mw.ustring.sub( self._yil, -2 )
		elseif anahtar == "YIL" then anahtar = self._yil
		elseif anahtar == "DORTLU" then anahtar = bul(self._yil, "-") and "-"..tostring(9999+tonumber(self._yil))
			or (string.len(self._yil) == 1 and "000"..self._yil
			or (string.len(self._yil) == 2 and "00"..self._yil
			or (string.len(self._yil) == 3 and "0"..self._yil
			or (string.len(self._yil) == 4 and self._yil)))) end
		table.insert(siraAnahtarlari, anahtar)
	end

	return siraAnahtarlari
end


function Kategori:toJSON()
	local ret = {
		ebeveynler = self:getirEbeveynler(),
		aciklama = self:getirAciklama(),
		asilAd = self:getirAsilAd(),
		yil = _yil,
		tip = _tip,
		sira_anahtari = self:getirSiraAnahtari(),
		sonHarfSil = self:sonHarfSil(),
		}
	
	return require("Modül:JSON").toJSON(ret)
end


function Kategori:getRawData()
	return self._rawData
end


Kategori.__index = Kategori


function olusturNesne(asilAd, veri, yil, tip, modul)
	return veri and
		setmetatable({ _rawData = veri, _asilAd = asilAd, _yil = yil, _tip = tip, _modul = modul }
			, Kategori)or nil
end


function tipHallet(ad, tip)
	local donKont = getirAsilAdaGore(ad, nil, tip)
	local goreSon = donKont:goreSon()
	local basta = donKont:basta()
	ad = donKont:donustur() and donKont:donustur() or ad

	tip = bul(ad, "kurulan") and "kurulduğu "..tip
		or (bul(ad, "feshedil") and "feshedildiği "..tip)
		or (bul(ad, "feshedilmiş") and "feshedildiği "..tip)
		or (bul(ad, "varlığı sona eren") and "feshedildiği "..tip)
		or (bul(ad, "kapa[tn][ıa][ln]") and "feshedildiği "..tip)
		or (bul(ad, "başlayan") and "başladığı "..tip)
		or (bul(ad, "sona eren") and "sona erdiği "..tip)
		or (bul(ad, "tamamlan") and "tamamlandığı "..tip)
		or (bul(ad, "tanıtıl") and "tanıtıldığı "..tip)
		or (bul(ad, "tanımlan") and "tanımlandığı "..tip)
		or (bul(ad, "oluşturulan") and "verilmeye başlandığı "..tip)
		or (bul(ad, "doğan%s") and "doğduğu "..tip)
		or (bul(ad, "doğumlu%s") and "doğduğu "..tip)
		or (bul(ad, "ölen%s") and "öldüğü "..tip)
		or (bul(ad, "keşfedilen%s") and "keşfedildiği "..tip)
		or (bul(ad, "fırlatılan%s") and "fırlatıldığı "..tip)
		or (bul(ad, "geçen%s") and "geçtiği "..tip)
		or (bul(ad, "yapan%s") and "yaptığı "..tip)
		or tip
	
	for _,d in ipairs(degerler) do
		ad = bulvedeg(ad, d.."%s", "")
	end
	
	if goreSon then
		return ad.." "..tip.."l"..(bul(tip, "dönem$") and "e" or "a").."r"
	elseif basta and not bul(ad, "göre") and not donKont:donustur() then
		bas = type(basta) == "table" and tipeGorePar(tip, basta) or basta
		return bas .. " " .. tip
			..(bul(tip, "dönem$") and "e" or "a")
			..(bul(ad, "göre") and " ve " or " göre ") .. bulvedeg(ad, bas, "")
	else
		return tip
			..(bul(tip, "dönem$") and "e" or "a")
			..(bul(ad, "göre") and " ve " or " göre ")
			..ad
	end
end


function getirAsilAdaGore(asilAd, yil, tip)
	local altsayfalar = {
		"veri",
		"veri/kişiler",
		"veri/sanat",
		"veri/bilim",
		"veri/kıtalara göre",
		"veri/şehirlere göre",
		"veri/yapılar",
		"veri/spor",
		"veri/hukuk",
		"veri/oluşumlar",
	}
	
	local verimodulu
	
	for _, altsayfa in ipairs(altsayfalar) do
		verimodulu = "Modül:Kategori/" .. altsayfa
		if require(verimodulu)[asilAd] then
			asilAd = type(require(verimodulu)[asilAd]) == "string" and require(verimodulu)[asilAd] or asilAd
			break
		end
	end
	
	tablo = mw.loadData(verimodulu)
	
	if not tablo[asilAd] then
		tablo = {[asilAd] = {}}
		if asilAd == "" then
			tablo[""] = {
				ebeveynler = {tip.."lar"},
				sira_anahtari = {"DORTLU"},
				kademe = 4,
			}
		end
		if bul(asilAd, "göre") then
			tip = "göre"
			tablo[asilAd] = {
				ebeveynler = {bulvedeg(asilAd, ".*göre%s", "")},
				sira_anahtari = {mw.ustring.char(0x0020)},
			}
		end
		verimodulu = "Modül:Kategori"
	end
	
	return olusturNesne(asilAd, tablo[asilAd], yil, tip, verimodulu)
end

---*---*---*---*---*---*---*---*---*---*---*---*---
-- nesneleri kategori sayfalarında yansıtan
-- fonksiyonlar
---*---*---*---*---*---*---*---*---*---*---*---*---

local function duzenleBag(altKat)
	--her kategoride "veriyi düzenle" bağlantısını eklemeye yarayan fonksiyon
	return "<div class=\"main-box main-box-for-all plainlinks\" style=\"float:right;padding:0\">\n{| class=\"main-table\"\n![" ..
		mw.getCurrentFrame():callParserFunction{name = "fullurl", args = {altKat, action = "edit"}} ..
		" Kategori verisini düzenle]\n|}</div>"
end

function parametreleriHallet(ad, yil, tip, yil2)
	local sonuc = ad
	
	if tip == "göre" then
		yil = tipHallet("", yil2)
	end
	if yil then
		sonuc = bulvedeg(sonuc, "{{{yıl}}}", yil)
		sonuc = bulvedeg(sonuc, "{{{yılda}}}", yilEki(yil))
	end
	
	return sonuc
end

--bu fonksiyon bir kategorinin bulunduğu yıla göre üst kısımda
--bir gezinti çubuğu oluşturur
function gezintiCubugu(kategori)
	--en başta bir tablo oluşturuyoruz, en sonda
	--bu tablonun içine sırayla yüklediğimiz gezinti
	--bağlantılarının çıktısını alacağız
	local tablo = {}
	
	--[[
		bu :getirAsilAd() değeri, bir kategori türünün yıldan
		sonra gelen kısmıdır, yani 2010'de eserler kategorisinde
		bu değer "eserler" dir
	
		burada sayfa son ekini belirliyoruz, yani herhangi bir yıldan
		sonra kategorinin adında gelen kısım, bunu kod satırı azaltmak
		amacıyla burada belirttik
	
		burada kontrol ettiğimiz şey de şu, eğer iki farklı değerimiz
		var ise, yani 2010 yılında doğanlar kategorisinde normalde
		bu değerin "yılında doğanlar" olması gerekir, fakat bunun bir üst
		kategorisi "2010'larda doğanlar" olduğu için burada iki farklı
		değeri birbirinden ayırmamız gerekiyor
	--]]
	local sayfa = kategori:getirAsilAd()
	
	--eğer en baştaki yıl değerine sonradan ihtiyacımız olursa diye,
	--bir sonYil değeri belirtiyoruz, çünkü gezinti çubuğunda sürekli
	--bu değer üzerinde oynama yapacağız
	local yil = kategori:getirYil()

	local function tekrarla(y, tip, sayfa)
		local function mevcutMu(sayfa)
			return mw.title.new('Kategori:' .. sayfa).exists
		end
		--5 tane alt kategori, 5 tane de üst kategoriyi çağırmalıyız
		for i = -5, 5 do
			--burada döngü her seferinde sayıyı bir artırarak
			--bize bir sonraki yıl değerini verecek
			local arYil = tipeGorePar(tip, {
				yilBul(y, i), onYil(y, i..0),
				yilBul(y, i) .. ". yüzyıl", yilBul(y, i) .. ". binyıl"
			})
			son = getirAsilAdaGore(sayfa, arYil, tip)
			--şimdi sayfaları kontrol edelim
			--MÖ 0'lar için özel durum
			if tip == "onyıl" and son:getirCubukAdi() == "0'lar" then
				if mevcutMu("MÖ "..son:getirKategoriAdi()) then
					table.insert(tablo, '\n*[[:Kategori:' .. "MÖ "..son:getirKategoriAdi() .. "|MÖ " .. son:getirCubukAdi() .. "]]")
				else
					table.insert(tablo, '\n*<span style="color:#888">MÖ ' .. son:getirCubukAdi() .. "</span>")
				end
			end
			--eğer kategorimiz "2020'de eserler" gibi "de, da" eki
			--içeren bir kategoriyse
			if mevcutMu(son:getirKategoriAdi()) then
				table.insert(tablo, '\n*[[:Kategori:' .. son:getirKategoriAdi() .. "|" .. son:getirCubukAdi() .. "]]")
			else
				--ya da o yıla dair, mevcut kategori türünde hiçbir sayfa mevcut değilse
				table.insert(tablo, '\n*<span style="color:#888">' .. son:getirCubukAdi() .. "</span>")
			end
		end
	end
	
	local function ebeveynKontrol(kategori, tablo, tip)
		if kategori:getirUstTip() and kategori:getirUstTip() == tip then
			--eğer bir yıl kategorisinin içerisindeysek ve ebeveyn kategoriler mevcutsa,
			--yani "2020'de eserler" için "2020'lerde eserler" kategorisi mevcutsa
			--bir ebeveyn çubuk tablo başı çağırabiliriz
			table.insert(tablo, '\n|}</div>')
			table.insert(tablo, '\n{| class="toccolours hlist" style="border: none; background: transparent;"'
				.. '\n! style="font-weight:400" |')
		end
	end
	
	--asil gezinti çubuğunun tablo başlangıcı
	table.insert(tablo, '<center><div style="padding-bottom: 10px"><div class=\"main-box\" style=\"display:inline-block;padding:0;margin-bottom:0;\">\n{| class="main-table hlist"'
		.. '\n! style="font-weight:400" |')
	
	--eğer bir yıl kategorisindeysek direk asil gezinti çubuğunda
	--yılları listeleyebiliriz
	if kategori:getirTip() == "yıl" then
		tekrarla(yil, "yıl", sayfa)
	end
	
	--ONYIL
	ebeveynKontrol(kategori, tablo, "onyıl")
	--şimdi gelelim on yılları listelemeye
	--eğer bir yıl veya on yıl kategorisindeysek on yılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "onyıl") or kategori:getirTip() == "onyıl" then
		tekrarla(yil, "onyıl", sayfa)
	end
	
	--YÜZYIL
	ebeveynKontrol(kategori, tablo, "yüzyıl")
	--şimdi gelelim yüzyılları listelemeye
	--eğer on yıl veya yüzyıl kategorisindeysek yüzyılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "yüzyıl") or kategori:getirTip() == "yüzyıl" then
		tekrarla(kategori:getirTip() == "yüzyıl" and yil or yuzYil(yil), "yüzyıl", sayfa)
	end
	
	--BİNYIL
	ebeveynKontrol(kategori, tablo, "binyıl")
	--şimdi gelelim binyılları listelemeye
	--eğer yüzyıl veya binyıl kategorisindeysek binyılları listeleyebiliriz
	if (kategori:getirUstTip() and kategori:getirUstTip() == "binyıl") or kategori:getirTip() == "binyıl" then
		tekrarla(kategori:getirTip() == "binyıl" and yil or binYil(yil), "binyıl", sayfa)
	end
	
	--sonunda tüm gezinti çubuklarının kapanışını yapıyoruz
	table.insert(tablo, '\n|}\n</div></center>')
	
	--ve hepsinin çıktısı da burada alınıyor
	return table.concat(tablo)
end

--yıllara ek getirmeye yarayan fonksiyon
--örnek olarak 2010'da veya 2015'te
function yilEki(yil)
	--bu durum ondalık yıllarda kullanılma durumlarında geçerlidir
	--yani 2010'larda, 2080'lerde gibi
	if bul(yil, "l[ea]r$") then
		local harf = mw.ustring.sub(yil, -2, -2)
		return yil .. "d" .. harf
	elseif bul(yil, "yüzyıl$") or bul(yil, "binyıl$") then
		return yil .. "da"
	elseif bul(yil, "%d") then
		--[[buradaki durumlarda bir yıla ek getirmek içindir
		    yani 2009'da veya 2003'te gibi
		    eğer yılın son rakamı "3,4,5" ise ekimizin ilk harfi
		    t olmalı çünkü bu rakamlarda kalın ek kullanıyoruz
		    bunların dışındaki durumlarda ise "d olacak"
		--]]
		local ilkek = bul(yil, "[345]$") and "t" or "d"
		--ve eğer son rakam "0,6,9" ise ekimizin ikinci harfi
		--a olur, kalan durumlarda ise e
		local sonek = bul(yil, "[069]$") and "a" or "e"
		--yukarıdaki durumlar birleştirildiğinde "de, da, te, ta"
		--eklerini elde edip çıkartacağız
		ilkek = (bul(yil, "40$") or bul(yil, "60$") or bul(yil, "70$")) and "t" or ilkek
		sonek = (bul(yil, "00$") or bul(yil, "20$") or bul(yil, "50$") or bul(yil, "70$") or bul(yil, "80$")) and "e" or sonek
		return yil .. "'" .. ilkek .. sonek
	else
		return yil
	end
end

--[[bu fonksiyon kategori adındaki yılı ve kategori tipini
    ayırt edip ayıklamaya yarar
    mesela "2017'de başlayan internet dizileri" kategorisini
    ele alalım bu ad, işleme sokulduğunda çıktıda elimize
    birinci değeri "2017" olan ve ikinci değeri de
    "yılda başlayan internet dizileri" olan bir tablo verir
--]]
function karsilastirYillari(ad)
	--yıl değerini başlatıyoruz
	local yil = ""
	local tip
	
	--bu bir MÖ yıl kategorisi mi?
	if bul(ad, "MÖ%s%d") then
		ad = bulvedeg(ad, "MÖ%s", "")
		mo = true
	end
	
	--kesme işareti bulunan bir sözcüğüz mü var?
	if bul(ad, "%a'[dt][ea]") then
		
	end
	
	--eğer girilen adın en başında bir rakam bulunuyorsa
	--bu demektir ki yılımız kategorinin başında mevcut
	--bu yılı en baştan ayıklayabiliriz
	if mw.ustring.match(ad, "%d+") then
		yil = mw.ustring.match(ad, "%d+")
		ad = bulvedeg(ad, yil, "SAYI")
		--eğer bir yıl saptayabildiysek bunu onaylayalım
		yilVarMi = true
	end
	
	--bir yıl değerimiz varsa
	if yilVarMi then
		--yılda de da eki varsa bunu silmemiz gerek
		--çünkü veri modülünden kategoriyi çağırırken
		--"yılda" ile başlayan değerler ile çağıracağız
		if bul(ad, "SAYI'[dt][ea]ki") then
			ad = bulvedeg(ad, "SAYI'[dt][ea]ki", "")
			tip = "yıl"
		elseif bul(ad, "SAYI'[dt][ea]") then
			ad = bulvedeg(ad, "SAYI'[dt][ea]", "")
			tip = "yıl"
		elseif bul(ad, "SAYI'l[ea]rd[ea]ki") then
			ad = bulvedeg(ad, "SAYI'l[ea]rd[ea]ki", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]rd[ea]") then
			ad = bulvedeg(ad, "SAYI'l[ea]rd[ea]", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]r") then
			ad = bulvedeg(ad, "SAYI'l[ea]r", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI'l[ea]r") then
			ad = bulvedeg(ad, "SAYI'l[ea]r", "")
			tip = "onyıl"
		elseif bul(ad, "SAYI. yüzyıldaki") then
			ad = bulvedeg(ad, "SAYI. yüzyıldaki", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. yüzyılda") then
			ad = bulvedeg(ad, "SAYI. yüzyılda", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. yüzyıl") then
			ad = bulvedeg(ad, "SAYI. yüzyıl", "")
			tip = "yüzyıl"
		elseif bul(ad, "SAYI. binyıldaki") then
			ad = bulvedeg(ad, "SAYI. binyıldaki", "")
			tip = "binyıl"
		elseif bul(ad, "SAYI. binyılda") then
			ad = bulvedeg(ad, "SAYI. binyılda", "")
			tip = "binyıl"
		elseif bul(ad, "SAYI. binyıl") then
			ad = bulvedeg(ad, "SAYI. binyıl", "")
			tip = "binyıl"
		else
			tip = "yıl"
			ad = bulvedeg(ad, "SAYI", "")
		end
		ad = bulvedeg(ad, "%s%s", " ")
		ad = bulvedeg(ad, "^%s", "")
		ad = bulvedeg(ad, "%s$", "")
		--çıktı tablomuzu alalım
		return {(mo and "-" or "") .. yil, ad, tip}
	else
		return {nil, ad}
	end
end

local function siraliSablon(sablon, t, l)
	if l[1] then
		table.insert(t, mw.getCurrentFrame():expandTemplate{
			title = sablon,
			args = {l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8], l[9]}})
	end
end

local function commons(kat, tablo)
	if kat:getirVikiveri() and kat:getirVikiveri().claims and kat:getirVikiveri().claims["P373"] then
		table.insert(tablo, mw.getCurrentFrame():expandTemplate{
			title = "Commons kategori",
			args = {kat:getirVikiveri():formatPropertyValues("P373").value}})
	end
end

local function styles (CSS_page)
	return mw.getCurrentFrame():extensionTag{
		name = "templatestyles", args = { src = CSS_page }
	}
end

function goster(frame)
	--ilk parametreye girilen değeri veya direk kategori adını işleme alalım
	local ad = frame.args[1] or mw.title.getCurrentTitle()["text"]

	--en son çıktı verecek kategoriler tablosu
	local kategoriler = {}
	--en son çıktı verecek görüntülenecek nesneler tablosu
	local goruntuler = {}
	
	--kategori sayfamızda bahsi geçen yıl
	local yil = karsilastirYillari(ad)[1]
	--kategori nesnemizi de çağıralım
	local kategori = getirAsilAdaGore(karsilastirYillari(ad)[2], yil, karsilastirYillari(ad)[3])
	
	table.insert(goruntuler, gezintiCubugu(kategori))
	table.insert(goruntuler, duzenleBag(kategori:getirVeriModulu()))

	--Commons kategorisi
	commons(kategori, goruntuler)
	
	if mw.title.new(ad).exists then
		table.insert(goruntuler, mw.getCurrentFrame():expandTemplate{
			title = "Ana",
			args = {ad}})
	end
	
	siraliSablon("Kategori ayrıca bakınız", goruntuler, kategori:getirBak())
	
	if kategori:getirAciklama() then
		table.insert(goruntuler, kategori:getirAciklama())
	end
	
	son = ""
	--her bir ebeveyn için gerekli kategorileri oluşturmamız gerekiyor
	for sira,ebeveyn in ipairs(kategori:getirEbeveynler()) do
		son = son .. ebeveyn:getirKategoriAdi()
		table.insert(kategoriler, "[[Kategori:" .. ebeveyn:getirKategoriAdi() .. "|" .. kategori:getirSiraAnahtari()[sira] .. "]]")
	end
	
	--kategori boş mu?
	if mw.site.stats.pagesInCategory(mw.title.getCurrentTitle().text, "all") == 0 then
		table.insert(kategoriler, "[[Kategori:Boş kategoriler]]")
	end
	
	return styles("Modül:Kategori/styles.css") .. table.concat(goruntuler) .. table.concat(kategoriler)
end

function gore(frame)
	local args = frame:getParent().args
	
	local kategoriler = {}
	local goruntuler = {}
	
	local yil = args[1]
	local tip = args[2]
	local kategori = getirAsilAdaGore(tip, yil, "göre")
	
	local gore = kategori:gore()
	
	if type(gore) == "table" then
		yukari = gore[2]
		gore = gore[1]
	end
	yukari = yukari or ((gore ~= "üst" and gore ~= "hayır") and gore)

	table.insert(goruntuler, mw.getCurrentFrame():expandTemplate{title = "kapsayıcı kategori", args = {}})
	
	--gezinti çubuğu
	if kategori:kademe() and kategori:kademe() > 1 then
		table.insert(goruntuler, "<center>")
		local donemKat = tipHallet(tip, "dönem")
		if mw.title.new("Kategori:" .. donemKat).exists then
			table.insert(goruntuler, '\n'
				..'[[:Kategori:' .. donemKat
				.. "|"..mw.getContentLanguage():ucfirst(donemKat).."]]</div>")
		elseif yil == "dönem" or gore == "üst" then
			table.insert(goruntuler, '\n'
				..'[[:Kategori:' .. (yukari or tip)
				.. "|"..mw.getContentLanguage():ucfirst(yukari or tip).."]]</div>")
		else
			table.insert(goruntuler, '\n'
				.."'''"
				..mw.getContentLanguage():ucfirst(donemKat).."'''</div>")
		end
		
		table.insert(goruntuler, '<div style="padding-bottom: 10px">'
			..'<div class=\"main-box\" style=\"display:inline-block;padding:0;margin-bottom:0;\">'
			..'\n{| class="main-table hlist"'
			.. '\n|')
		
		for _, kademe in ipairs(kademeler) do
			local kademeAdi = tipHallet(kategori:donustur() and kategori:donustur() or kategori:sonHarfSil(kademe), kademe)
			if mw.title.new("Kategori:" .. kademeAdi).exists then
				table.insert(goruntuler, "\n*[[:Kategori:" .. kademeAdi
					.. "|".. mw.getContentLanguage():ucfirst(tipHallet("", kademe)) .."]]")
			end
		end
		
		table.insert(goruntuler, '\n|}\n</div></div></center>')
	end

	table.insert(goruntuler, duzenleBag(kategori:getirVeriModulu()))
	
	--Commons kategorisi
	commons(kategori, goruntuler)
	
	siraliSablon("Kategori ayrıca bakınız", goruntuler, kategori:getirBak())
	
	if kategori:getirAciklama() then
		table.insert(goruntuler, kategori:getirAciklama())
	end
	
	for _,d in ipairs(degerler) do
		tip = (yil == "dönem" or gore == "üst") and bulvedeg(tip, "^"..d.."%s", "") or tip
	end
	
	if yil == "dönem" and gore == "hayır" then
	elseif yil == "dönem" or gore == "üst" then
		table.insert(kategoriler, "[[Kategori:" .. mw.getContentLanguage():ucfirst(yukari or tip) .. "|+]]")
	elseif bul(tip, "^tipe göre") or bul(tip, "^ülkeye göre") then else
		table.insert(kategoriler, "[[Kategori:".. tipHallet(tip, "dönem").. "| ]]")
	end
	
	if kategori:getirEbeveynler() then
		--her bir ebeveyn için gerekli kategorileri oluşturmamız gerekiyor
		for sira,ebeveyn in ipairs(kategori:getirEbeveynler()) do
			table.insert(kategoriler, "[[Kategori:" .. ebeveyn:getirKategoriAdi(kategori:goreTipi()) .. "|"
				.. (mw.site.stats.pagesInCategory(ebeveyn:getirKategoriAdi(kategori:goreTipi()), "subcats") > 200
					and mw.ustring.char(0x0020)
					or (bul(tip, "göre") and "+" or kategori:getirSiraAnahtari()[sira]))
				 .. "]]")
		end
	end
	
	return styles("Modül:Kategori/styles.css") .. table.concat(goruntuler) .. table.concat(kategoriler)
end

return {goster = goster, gore = gore, tipHallet = tipHallet, test = test}