Module:Ortografeyes

I gn a nén co di dzo-pådje /doc pol notule d’ esplikêyes. Clitchîz cial po l’ ahiver.

-- This module makes a list of different 
-- orthographies for a word based on a list of well known references.
-- Only use with Modele:Orto as :
--[[ 

{{Orto
|bondjoû = C8, C9, E34, O0, O3, O4
|bondjou = E1, O2
|bôdjoû = E34
}}

]]--
 
local p = {}
local base = require("Module:Base")
local sourdant = require("Module:Sourdant");
local category = require("Module:Categoreyes");
local lingaedje = require("Module:Lingaedje");
local riscr = require("Module:Riscrijhaedje");

local lang = "wa"
local langObj = mw.language.new(lang)
local cat = "mots"
local pagename = ""
local references = {}
local groups = {}
local groupsID = {}
local words = {}
local output_lst = {}
local total_known = 0

--- pad str to the left
string.lpad = function(str, len, char)
    if char == nil then char = ' ' end
    return string.rep(char, len - #str) .. str
end
--- encode string for url
string.url_encode = function(str)
	local str, t = string.gsub(str,"[^%w]",function(c) 
		return string.format("%%%X",string.byte(c)) end)
	return str
end
-- escape % in string replacement with gsub
string.escape_pattern = function(str)
    local str, t = string.gsub(str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
    return str
end

function p.build_cat_grp(word, grpID)
	-- if lang is walloon
	if word == pagename and lang == "wa" and 
	   grpID ~= 'rif' and 
	   output_lst['rif'] ~= nil and
	   output_lst['rif'][word] ~= nil then
		for word,ref in pairs(words[word]) do
			if(references[ref] ~=nil and
			   references[ref].group ~= 'rif') then
				catPrefix = langObj:ucfirst(cat)
				category.store(catPrefix.." ki l' rifondowe est dins "..ref, true)
			end
			-- for words before 1900
			if (grpID == "d1900") then
				category.store("Mots ki l' rifondowe egzistéve dedja dins ene ortografeye di dvant Feller", true)
			-- for words in scripta
			elseif (grpID == "vscr" ) then
				category.store("Mots ki l' rifondowe egzistéve dedja dins li scrîta", true)
			end
		end
	end
end

-- make a group of references
function p.build_groups()
	html = ""
	for k, grp in ipairs(groups) do
		grpID =grp.id
		if output_lst[grpID] ~= nil then	
			html = html .. '<div class="og og-'..grpID..'">'
			if grpID == "not" then
				refs = output_lst[grpID]["-"]
				html = html .. '<i>Li mot n’ est nén dins :</i> '..refs
			else
				local li = ''
				local cat = ''
				local style_columns = ''
				local tli = 0
				local ling = lang

				if ling == "wa" then
					if grpID == "vscr" or grpID == "d1900" then
						ling = ling .. "-vsis"
					elseif grpID == "s20es" then
						ling = ling .. "-fel"
					end
				end

				for word,refs in pairs(output_lst[grpID]) do	
					local fw = string.match(word, "%[%[")
					local lw = word
					if not fw then
--						lw =  "[["..word.."]]"
						-- handle things like: "r(i)gon (rigon / r'gon)"
						-- we add two following [^(] to _NOT_ match things like "s(i)ticler / (e)sticler"
						fw = string.find(word, " %([^%)][^%)]")
						if fw then
							local strbegin = string.sub(word, 1, fw - 1)
							strbegin = riscr.get_article_link(strbegin, "", ling)
							local strend = string.sub(word, fw + 2)
							strend = string.gsub(strend, "%)$", "")
							-- if "/text/" then it is a phonetic transcription, keep unchanged
							-- else we linkify it
							if not string.match(strend, "/[^ ][^/]+[^ ]/") then
								strend = riscr.get_article_link(strend, "", ling)
								if string.match(strend, " / ") then
									strend = riscr.split_article_link( strend )
								end
							end
							lw = strbegin .. " ( " .. strend .. " )"
						else
							fw = string.find(word, " / ")
							if fw then
								local strbegin = string.sub(word, 1, fw - 1)
								strbegin = riscr.get_article_link(strbegin, "", ling)
								local strend = string.sub(word, fw + 2)
								strend = riscr.get_article_link(strend, "", ling)
								-- just in case
								if string.match(strend, " / ") then
									strend = riscr.split_article_link( strend )
								end
								lw = strbegin .. " / " .. strend
							else
								lw = riscr.get_article_link(word, "", ling)
							end
						end
						
						-- bold to itself is lost if there is an anchor
						-- we need to check also pagename for special chars to escape
						fw = string.gsub(lw, 
							"%[%[" .. string.escape_pattern(pagename) .. "#([^%]]*)|([^%]]*)%]%]",
							"'''" .. "%2" .. "'''" )
						if fw ~= nil then
							lw = fw
						end
					end
					
					-- change anchor for old spellings of rifondou
					if ling == "wa" and string.match(refs, "rifondaedje ricandjî enawaire") then
						lw = string.gsub(lw, "#Walon%|", "#Walon (viye rifondowe)|")
					end

					li = li .. '<li>'..lw..' : '..refs..'</li>'
					tli = tli+1
					
					-- make cat if needed
					p.build_cat_grp(word, grpID)
					
				end
				
				-- display list by columns for numerous items 
				if tli >=9 then
					style_columns = ' class="c-3"'
				elseif tli >=4 then
					style_columns = ' class="c-2"'
				end
				
				html = html .. '<div class="ogt">'..grp.title..' :</div>'
				html = html .. '<div'..style_columns..'><ul>'..li..'</ul></div>'
				
				
				html = html .. cat -- add all cats
			end
			html = html .. '</div>'
		end
	end
	
	return html
end

-- if word needs to be transformed for external ressource
function p.word_transform (word, transfrom)
	if transfrom == "ucfirst" then
		local w1 = mw.ustring.upper(mw.ustring.sub(word, 1, 1))
		local w2 = mw.ustring.sub(word, 2)
		word = w1 .. w2
	elseif transfrom == "uc" then
		word = mw.ustring.upper(word)
	end
		
	return word
end

-- make a reference in wikicode
function p.build_ref (ref, refID, word, refQ)
	if refID ~= nil and references[refID] ~= nil then
			
		local r = nil
		local refID_real = refID
		if references[refID].alias ~= nil then
			r = references[refID].alias
			refID = r.id
		else
			r = references[refID]
		end
		
		-- ref informations for abbr
		-- author(s), title, year | RefID
		local abbr_title = table.concat(r.info, ", ")
		
				
		-- ref link
		if ref == refID then
			ref = "[[Sourdant:"..ref.."|<abbr title=\""..abbr_title.."\">"..ref.."</abbr>]]"
		elseif refQ ~=nil then
			local refIDQ = refID_real..":"..refQ
			ref = string.gsub(ref, string.escape_pattern(refIDQ), '[[Sourdant:'..refID..'|<abbr title="'..abbr_title..'">'..refID_real..'</abbr>]]')
		else
			ref = string.gsub(ref, refID_real, '[[Sourdant:'..refID..'|<abbr title="'..abbr_title..'">'..refID_real..'</abbr>]]')
		end
						
		
		if word ~= '-' then
			-- add link to wikisource
			if r.wikisource ~= nil then
				local w = r.wikisource
				if w.title ~= nil then
					-- for E89:other_word
					if refQ ~= nil then
						word = mw.text.trim(refQ)
					end
					if word ~= "" then
						if w.transform ~= nil then
							word = p.word_transform(word, w.transform)
						end
						
						local t = string.gsub(w.title, '__WORD__', word)			
						local l = ""
						if w.lang ~= "wa" then l = ":"..w.lang end
						ref = ref.. ' <sup>([[:oldwikisource'..l..':'..t..'|lére]])</sup>'
					end
				end
			
			-- add external link
			elseif r.external ~= nil then
				local ext = r.external
				local query = nil
				
				-- for R10:1841, Ref1:OtherWord, ...
				if ext.queryID ~= nil and refQ ~= nil then
					query = ext.queryID
					word = refQ
				elseif ext.query ~= nil then
					query = ext.query
					if refQ ~= nil and refQ == '' then
						word = ''
					end
				end
				
				if query ~= nil and word ~= '' then
					if ext.transform ~= nil then
						word = p.word_transform(word, ext.transform)
					else
						if refQ == nil and string.match( word, "%(") 
							and (lang == "wa" or lang == "wa-fel")
						then
							word = riscr.betchete_cogne_motli(word)
						end
					end
				
					query = string.gsub(query, '__WORD__', string.escape_pattern(string.url_encode(word)))
					ref = ref.. ' <sup class="plainlinks">(['..query..' lére])</sup>'
				end

			-- add link to wikipedia
			elseif r.wikipedia ~= nil then
				w = r.wikipedia
				if w.article ~= nil then
					-- for R11:extra
					if refQ ~= nil then
						if string.match(refQ, '^[1-9]') then
							word = word .. '_' .. mw.text.trim(refQ)
						elseif refQ ~= '-' then
							word = mw.text.trim(refQ)
						else
							word = ""
						end
					end
					if word ~= "" then
						if w.transform ~= nil then
							word = p.word_transform(word, w.transform)
						else
							if refQ == nil and string.match( word, "%(") 
								and (lang == "wa" or lang == "wa-fel")
							then
								word = riscr.betchete_cogne_motli(word)
							end
						end
						
						local t = string.gsub(w.article, '__WORD__', word)			
						ref = ref.. ' <sup>([[:w:'..w.lang..':'..t..'|lére]])</sup>'
					end
				end
			end	
		end
	end
			
	return ref
end

-- sort references by group
function p.sort_ref (word, ref)
	local li = ""
	local g = "unknown"
	local refID = nil
	local refQ = nil
	
	-- escape spaces in syntax ID:<some words with spaces>
	-- alternative of ID:some_words_with_spaces
	ref = string.gsub(ref, "%:<[^>]+>", function(w) return ":"..string.sub(string.gsub(w, ' ', '_'),3,-2) end)
	
	-- get ID ref (E89, E212b, PiB2, R10:1842, ...)
	local refPattern = "([A-Z]+[A-Za-z0-9]+)(%:?[^%s]*)"
	refID, refQ = string.match(ref, refPattern)
	if refQ ~= nil and refQ ~= "" then 
		refQ = string.sub(refQ, 2)
	else
		refQ = nil -- string.match gives empty string
	end
	
	if refID ~= nil then
		if	references[refID] ~= nil or	p.load_reference(refID) then
			g = references[refID].group
			total_known = total_known + 1  
			if pagename == word then
				-- not cat for author
				if not references[refID].isauthor then
					catPrefix = langObj:ucfirst(cat)
					category.store(catPrefix.." ki sont dins "..refID, true)
				end
			end
		end
	else
		category.store("Årtikes avou des sourdants nén rkinoxhous dins l' modele ortografeyes")
	end
	
	-- forced group ([!d1900], ...)
	local fg = string.match(ref, "%[![A-Za-z0-9]+%]")
	if fg ~= nil then
		fgid = string.sub(fg, 3, -2)
		if groupsID[fgid] ~= nil then
			g = fgid
			ref = string.gsub(ref, "%[!"..fgid.."%]", '')
			category.store("Årtikes avou des adjinçnaedjes di troke dins l' modele ortografeyes")
		end
		
	end
		
	-- collecte refs by word
	if words[word] == nil then
		words[word] = {refID}
	else	
		table.insert(words[word], refID)
	end
			
	-- for 'not' group
	if word == "-" or word == "nén dins" then
		g = "not"
		word = "-" -- FIXME we should delete this
	end

	-- check that the group does exist for the loaded language
	if g == nil or groupsID[g] == nil then
		g = 'unknown'
	end

	-- add ref in group
	li = p.build_ref(ref, refID, word, refQ)
	if g ~=nil then
		if output_lst[g] == nil then
			output_lst[g] = {}
		end
		if output_lst[g][word] ~= nil then
			output_lst[g][word] = output_lst[g][word] .. ', '..li
		else
			output_lst[g][word] = li
		end	
	end	
end

-- load reference
-- we don't need all informations, only
--  group 
--  author(s), title, year, (alt)pub
--  wikisource or external
function p.load_reference(refID)
	local ref = sourdant.get_reference(refID)
	
	if ref then
		refID = ref.id
		references[refID] = {}
		
		if groupsID["all"] ~= nil then
			references[refID].group = 'all'
		elseif ref.group ~= nil then 
			references[refID].group = ref.group
		else
			references[refID].group = 'unknown'
		end
		
		-- aliases
		if ref.aliases ~= nil then
			for k, a in pairs(ref.aliases) do
				references[a.id] = {}
				references[a.id].alias = references[refID]
				if a.group ~= nil then
					references[a.id].group = a.group
				else
					references[a.id].group = references[refID].group
				end
			end
		end
		
		--ID
		references[refID].id = ref.id 
		
		references[refID].info = {}
		-- author(s)
		if ref.alt_authors and ref.alt_authors ~= '' then
			table.insert(references[refID].info, ref.alt_authors)
		elseif ref.authors and ref.authors ~= '' then
			table.insert(references[refID].info, ref.authors)
		elseif ref.alt_author and ref.alt_author ~= '' then
			table.insert(references[refID].info, ref.alt_author)
		elseif ref.author and ref.author ~= '' then
			table.insert(references[refID].info, ref.author)
		end
		
		-- title (if title missing then author) 
		if ref.title and ref.title ~= '' then
			references[refID].isauthor = false
			table.insert(references[refID].info, ref.title)
		else
			references[refID].isauthor = true
		end
		
		--alt_publication or (year & pub)
		if ref.alt_publication and ref.alt_publication ~= '' then
			table.insert(references[refID].info, ref.alt_publication)
		else
			-- year & pub
			if ref.year and ref.year ~= '' then
				local yearpub = ref.year
				if ref.pub and ref.pub ~= '' then
					yearpub = yearpub .. " " .. ref.pub
				end
				table.insert(references[refID].info, yearpub)
			end
		end
		
		-- wikisource
		if ref.wikisource then
			references[refID].wikisource = ref.wikisource
		-- or external
		elseif ref.external then
			references[refID].external = ref.external
		-- or wikipedia
		elseif ref.wikipedia then
			references[refID].wikipedia = ref.wikipedia
		end
				
		return true
	end
		
	return false
end

-- load groups
function p.load_groups()
	
	local grps = base.load_data("Ortografeyes/groups-"..lang)
			
	if grps then
		-- because base.load_data() return a read-only table
		for k, g in ipairs(grps) do
			-- we need to make a copy in 'groups' table
			table.insert(groups, k, g)
			-- and another to access group easily by id
			groupsID[g.id] = groups[k]
		end
	else
		-- add groups 'all' when there is no group
		table.insert(groups, {id="all", title = "Totes les ortografeyes"})
		groupsID["all"] = groups[#groups]
	end

	-- add groups 'unknown' & 'not' (for 'word is not in this ref')
	table.insert(groups, {id="unknown", title = "Ôtes ortografeyes (avou des sourdants nén rkinoxhous)"})
	groupsID["unknown"] = groups[#groups]
	table.insert(groups, {id="not", title = "Nén dins"})
	groupsID["not"] = groups[#groups]
	
	return true -- always ?
end

-- make list
function p.render(orto)
	local html = '<div class="g-or ortografeyes">'
	local ref = ""
			
	-- for each word
	for word, refs in pairs(orto) do	
		if word ~= "lang" and word ~= "cat" then -- FIXME see p.init()
			word = mw.text.trim(word)
			-- escape comma	
			refs = string.gsub(refs, "\\,", "\\x2C")	
			refs = mw.text.split(refs, ",", true)
			for key,ref in ipairs(refs) do	
				-- comma	
				ref = string.gsub(ref, "\\x2C", ",")
				ref = mw.text.trim(ref)
				
				p.sort_ref(word, ref) 					
			end	
		end		
	end
		
	html = html .. p.build_groups()
	html = html .. '</div>'
	
	if total_known == 0 then
		local linktxt = lingaedje.grammar({args={"Djivêye des motîs",lang,"",vowel='1'}});
		html = '<p class="info">I gn a co rén dins ci hagnon ci, mins si vos irîz rnaxhî dins des ôtes motîs, et trover l’ mot « <b>'..pagename..'</b> », riherez ciddé li scrijha do mot ki vos î avoz trové, et l’ rahouca do motî el [[Sourdant:'..linktxt..'|'..linktxt..']].</p>'
		category.store(lingaedje.grammar({args={"Mots",lang,"avou des ortografeyes a radjouter",vowel='1'}}))
	end
	
	html = html .. category.get_all()
    return html
end

-- Entry point of the module
function p.init(frame)
	
	-- get args from parent modele
	local modele = mw.getCurrentFrame():getParent()
	local args = modele.args
		
	-- set lang
	if args.lang ~= nil then
		lang = args.lang
	end
	
	-- set category (dijhêye, spots and mots ???)
	if args.cat ~= nil then
		if args.cat == "spot" or args.cat == "spots" then
			cat = "spots"
		elseif args.cat == "dijhêye" or args.cat == "dijhêyes" then
			cat = "dijhêyes"
		end
	end
	
	-- set page name
	pagename = mw.title.getCurrentTitle().text
	
	p.load_groups()
							
	return p.render(args)
	
end

return p