Moduł:Dopracować

Z Wikibooks, biblioteki wolnych podręczników.
Przejdź do nawigacji Przejdź do wyszukiwania
Template-info.png Dokumentacja modułu [zobacz] [edytuj] [historia] [odśwież]

Moduł techniczny wspierający szablon {{dopracować}}. Wszelkie instrukcje użycia są przedstawione na stronie dokumentacji szablonu.

Podstawowe funkcje

test

Funkcja do sprawdzania, czy szablon {{dopracować}} jest wywołany z parametrami określającymi powody jego umieszczenia. Jeśli żadnych powodów nie podano to zwraca pusty tekst.

ikona

Funkcja zwraca zwraca wartość icon danego problemu lub jego wartość domyślną.

tekst

Funkcja do generowania treści wyświetlanej przez szablon {{dopracować}}.

Dodatkowe funkcje

nadmiarowe

Funkcja sprawdza, czy w szablonie {{dopracować}} nie ma nadmiarowego zbioru parametrów.

nieznane

Funkcja sprawdza, czy szablon {{dopracować}} przyjmuje nieznane nazwane parametry.

powtarzające

Funkcja sprawdza, czy w szablonie {{dopracować}} występują powtarzające się parametry nazwane i nienazwane.
local resources = mw.loadData( 'Moduł:Dopracować/resources' )
function NoweZwrocone(result)
	for i, v in ipairs(resources.compact or {}) do
		local r, c = mw.ustring.gsub(result, v.pattern, v.replace)
		if c > 0 then
			result = r
			break
		end
	end
	return result
end
return {
	test = function(frame)
		local parametry_modul=require("Module:Parametry");
	    local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
		
		-- scan reasons without dates
		local sectionParamIndex = resources.data.sectionParamIndex
		local sectionParamValue = resources.data.sectionParamValue
		for i, _ in ipairs(pf.args) do
			local object = pf:getArgument(i)
			if object then
				local reason = object:expand()
				if reason and ((i ~= sectionParamIndex) or (reason ~= sectionParamValue)) then
					if #mw.text.trim(reason) > 0 then
						return "tak"
					end
				end
			end
		end
	
		-- scan well known reasons with optional date
		for _, v in ipairs(resources.reasons) do
			for _, k in ipairs(v.aliases) do
				local object = pf:getArgument(k)
				if object then
					local currentDate = object:expand()
					if currentDate then
						return "tak"
					end
				end
			end
		end
	
		return nil
	end,
	
	ikona = function(frame)
		local parametry_modul=require("Module:Parametry");
	    local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
 
		local onlyReason = nil
 
		local mapParamToReason = {}
		for i, v in ipairs(resources.reasons) do
			for _, a in ipairs(v.aliases) do
				mapParamToReason[a] = i
			end
		end
 
		-- scan well known reasons with date
		for k, i in pairs(mapParamToReason) do
			local object = pf:getArgument(k)
				if object then
					local currentDate = object:expand()
						if currentDate then
					    	if not onlyReason then
								onlyReason = i
					    	elseif onlyReason ~= i then
								onlyReason = 0
								break
							end
						end
				end
		end
            
        -- scan reasons without dates
		if not onlyReason then
			for i, reason in  ipairs(pf.args) do
				--local object = pf:getArgument(i)
				--if object then
				--	local reason = object:expand()
				if reason and ((i ~= resources.data.sectionParamIndex) or (reason ~= resources.data.sectionParamValue)) then
					if mw.text.trim(reason) ~= "" then
						local known = mapParamToReason[reason]
						if known then
							if not onlyReason then
								onlyReason = known
							elseif onlyReason ~= known then
								onlyReason = 0
								break
							end
						end
					   end
				end
			end
		end
		local icon = nil
		if onlyReason then
			local reasonData = resources.reasons[onlyReason]
			if reasonData then
				icon = reasonData.icon
			end
		end
 
		return icon or resources.default.icon
	end,
	nadmiarowe = function(frame)
		local parametry_modul=require("Module:Parametry");
	    local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
		local tabela_aliasow={}
		local nazwy_modul=require("Module:Nazwy");
		local nazwa_polska=nazwy_modul.NpFun{nazwa=frame.args["Kategoria"]};
		for i, dostepny_problem in ipairs(resources.reasons) do
			 for numer_przestrzeni, element_obslugiwanej_przestrzeni in ipairs(dostepny_problem.space)do
		 		if(nazwy_modul.NpFun{nazwa=element_obslugiwanej_przestrzeni}==nazwa_polska)then
		 			 for numer_aliasu, element_aliasu in ipairs(dostepny_problem.aliases) do
		 		 		tabela_aliasow[element_aliasu]=i
		 			end
		 		end
			end
		end
		local mapParamToReason = {}
    	for i, v in ipairs(resources.reasons) do
			for _, a in ipairs(v.aliases) do
				mapParamToReason[a] = i
			end
		end
		for name, wartosc_argumentu in pairs(pf.args)do
   			if(type(name)=="number")then
   				local wytrimowana_wartosc_argumentu=mw.text.trim(wartosc_argumentu)
   				local liczba=mapParamToReason[wytrimowana_wartosc_argumentu]
   				if(liczba)then 
   					if(not tabela_aliasow[wytrimowana_wartosc_argumentu])then
   						return "tak"
   					end
   				end
   			else
   				local wytrimowana_wartosc_argumentu=mw.text.trim(name)
   				local liczba=mapParamToReason[wytrimowana_wartosc_argumentu]
   				if(liczba)then
   					 if(not tabela_aliasow[wytrimowana_wartosc_argumentu])then
   				 		return "tak"
   					end
   				end
   			end	
		end
		return ""
	end,
	nieznane = function (frame)
		local parametry_modul=require("Module:Parametry");
	    local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
		local mapParamToReason = {}
		for i, v in ipairs(resources.reasons) do
			for _, a in ipairs(v.aliases) do
				mapParamToReason[a] = i
			end
	     end
	     local czy_znany_parametr=true
	     for argument, _ in pairs(pf.args) do
	      if(type(argument) ~= "number")then
			for argument2,_ in pairs(mapParamToReason) do
				if(argument==argument2)then czy_znany_parametr=false break end;
			end
			for _,dostepny_argument in ipairs(resources.dostepne_parametry) do
				if(argument==dostepny_argument)then czy_znany_parametr=false break end;
			end
			if(czy_znany_parametr)then return "tak" end
			czy_znany_parametr=true
		  end
		end
		return ""
     end,
    ["powtarzające"] = function(frame)
		local parametry_modul=require("Module:Parametry");
	    local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
    	local tablica_aliasow={};
        for licznik,dostepny_problem in ipairs(resources.reasons) do
    		for _,problem in ipairs(dostepny_problem.aliases)do
    			for licznik2,argument in pairs(pf.args)do
    			   if(type(licznik2)=="number")then
    			   	  if(argument==problem)then
    			   	  	tablica_aliasow[#tablica_aliasow+1]=dostepny_problem.aliases[1]
    			   	  end
    			   elseif(type(licznik2)=="string")then
    			  	  if(licznik2==problem)then
    			  	  	 tablica_aliasow[#tablica_aliasow+1]=dostepny_problem.aliases[1]
    			  	  end
    			   end
    			end
    		end
    	end
    	if(#tablica_aliasow>0)then
    		for licznik=1,#tablica_aliasow,1 do
    			for licznik2=1,licznik-1,1 do
    				if(tablica_aliasow[licznik]==tablica_aliasow[licznik2])then
    					return "tak"
    				end
    			end
    		end
    	end
    	return ""
    end,
	tekst = function(frame)
		    local parametry_modul=require("Module:Parametry");
	        local pf = (parametry_modul.CzyTak(frame.args["wyspecjalizowana"]))and frame or frame:getParent();
		    local frame2=pf:newChild{ title = "Przykładowy", args = {}};
		    local pudelko_modul=require("Module:Pudełko");
			local nazwa_przestrzeni_nazw=pudelko_modul["Nazwa przedmiotowej przestrzeni nazw"](frame2);
			local nazwij_jednostka=pf.args["nazwij jednostką"]
	    	local typ_jednostki=pudelko_modul["Przedmiotowy typ jednostki"](frame2);
	    	local nazwa_jednostki=pudelko_modul["Nazwa jednostki"](frame2);
	    	local pelna_nazwa_jednostki=(nazwa_przestrzeni_nazw~="")and nazwa_przestrzeni_nazw..":"..nazwa_jednostki or nazwa_jednostki;
	    	local title=mw.title.makeTitle('',pelna_nazwa_jednostki);
	    	function prepareTemplates(reason, date, section, comments)
		    	local c = (reason)and (reason["?"] or {}) or {}
				local sourceTemplates;
				local templates = {};
				function TemplatesFunkcja(templates,section)
			       	sourceTemplates=(section) and resources.sectionTemplates or resources.otherTemplates
			       	templates["{{unit type}}"]="Jednostki"
        			templates["{{comma}}"]="";
        			return sourceTemplates
			    end;
			    function Templates()
			    	if((nazwij_jednostka)and(nazwij_jednostka~=""))then
			    		sourceTemplates = (section) and resources.sectionTemplates or resources.otherTemplates
			    		templates["{{unit type}}"]="Jednostki"
        				templates["{{comma}}"]="";
					elseif((nazwa_przestrzeni_nazw==resources.data.defaultuser)and(typ_jednostki=="jednostka użytkownika"))then
						sourceTemplates = (section) and resources.sectionTemplates or resources.userTemplates
					    templates["{{unit type}}"]="Jednostki użytkowników"
	    			    templates["{{comma}}"]=",";
    				elseif((nazwa_przestrzeni_nazw==resources.data.defaulthelp)and(typ_jednostki=="strona pomocy"))then
						sourceTemplates = (section) and resources.sectionTemplates or resources.pomocTemplates
					    templates["{{unit type}}"]="Strony pomocy"
	    	    	    templates["{{comma}}"]=",";
    		    	elseif(nazwa_przestrzeni_nazw==resources.data.defaultwikibooks)then
						if(typ_jednostki=="jednostka brudnopisu projektu")then
    						sourceTemplates = (section) and resources.sectionTemplates or resources.documentationdraftprojectTemplates;
    						templates["{{unit type}}"]="Jednostki brudnopisu projektu"
    					elseif(typ_jednostki=="strona projektu")then
							sourceTemplates = (section) and resources.sectionTemplates or resources.projektTemplates;
							templates["{{unit type}}"]="Strony projektu"
						else
						    sourceTemplates=TemplatesFunkcja(templates,section);
						end;
        	    		templates["{{comma}}"]=",";
					elseif(nazwa_przestrzeni_nazw==resources.data.defaulttemplate)then--
						if(typ_jednostki=="strona brudnopisu opisu szablonu")then
							sourceTemplates = (section) and resources.sectionTemplates or resources.documentationdrafttemplateTemplates
							templates["{{unit type}}"]="Strony brudnopisu opisu szablonów"
    					elseif(typ_jednostki=="strona opisu szablonu")then
							sourceTemplates = (section) and resources.sectionTemplates or resources.documentationtemplateTemplates;
						    templates["{{unit type}}"]="Strony opisu szablonów"
						else
						    sourceTemplates=TemplatesFunkcja(templates,section);
						end;
					    templates["{{comma}}"]=",";
					elseif(nazwa_przestrzeni_nazw==resources.data.defaultmodule)then--
						if(typ_jednostki=="strona brudnopisu opisu modułu")then
							sourceTemplates = (section) and resources.sectionTemplates or resources.documentationdraftmoduleTemplates;
							templates["{{unit type}}"]="Strony brudnopisu opisu modułów"
    					elseif(typ_jednostki=="strona opisu modułu")then
							sourceTemplates = (section) and resources.sectionTemplates or resources.documentationmoduleTemplates
							templates["{{unit type}}"]="Strony opisu modułów"
						else
						    sourceTemplates=TemplatesFunkcja(templates,section);
						end;
						templates["{{comma}}"]=",";
					elseif((nazwa_przestrzeni_nazw==resources.data.defaultcategory)and(typ_jednostki=="strona kategorii"))then
			    		sourceTemplates = (section) and resources.sectionTemplates or resources.categoryTemplates
			    		templates["{{unit type}}"]="Strony kategorii"
						templates["{{comma}}"]=",";
					elseif(nazwa_przestrzeni_nazw==resources.data.defaultmainspace)then
						   if(typ_jednostki=="artykuł")then
			    		        sourceTemplates=(section) and resources.sectionTemplates or resources.articleTemplates;
			    		        templates["{{unit type}}"]="Artykuły"
						        templates["{{comma}}"]="";
			    		    elseif(typ_jednostki=="podręcznik")then
			    		    	sourceTemplates=(section) and resources.sectionTemplates or resources.manualTemplates;
			    		    	templates["{{unit type}}"]="Podręczniki"
						        templates["{{comma}}"]="";
						    else
						    	sourceTemplates=TemplatesFunkcja(templates,section);
			    			end;
					elseif(nazwa_przestrzeni_nazw==resources.data.defaultwikijunior)then
						   if(typ_jednostki=="artykuł dla dzieci")then
			    		        sourceTemplates=(section) and resources.sectionTemplates or resources.articleTemplates;
			    		        templates["{{unit type}}"]="Artykuły dla dzieci"
						        templates["{{comma}}"]=",";
			    		    elseif(typ_jednostki=="podręcznik dla dzieci")then
			    		    	sourceTemplates=(section) and resources.sectionTemplates or resources.manualTemplates;
			    		        templates["{{unit type}}"]="Podręczniki dla dzieci"
						        templates["{{comma}}"]=",";
							else
						    	sourceTemplates=TemplatesFunkcja(templates,section);
			    		    end;
			    	else
			       		sourceTemplates=TemplatesFunkcja(templates,section);
			    	end;
			    end;
                Templates();
				for k, v in pairs(sourceTemplates) do
					templates[k] = v
				end
       	        if(nazwa_przestrzeni_nazw==resources.data.defaultwikijunior)then
            		templates["{{M}}"] = templates["{{M}}"].." dla dzieci"
            		templates["{{B}}"] = templates["{{B}}"].." dla dzieci"
            		templates["{{d}}"] = templates["{{d}}"].." dla dzieci"
            		templates["{{ms}}"] = templates["{{ms}}"].." dla dzieci"
	        		templates["{{w}}"] = templates["{{w}}"].." dla dzieci"	
	        		templates["{{MS}}"] = templates["{{MS}}"].." dla dzieci"
		    		templates["{{MD}}"] = templates["{{MD}}"].." dla dzieci"
		    		templates["{{BD}}"] = templates["{{BD}}"].." dla dzieci"
		    		templates["{{dm}}"] = templates["{{dm}}"].." dla dzieci"
		    		templates["{{bm}}"] = templates["{{bm}}"].." dla dzieci"
            	end;
				templates[resources.data.dateTemplate] = date or ""
				if title.talkPageTitle then
					templates[resources.data.talkNameTemplate] = title.talkPageTitle.fullText
				end
				templates["{{FULLPAGENAMEE}}"] = mw.uri.encode(title.fullText, "WIKI")
				templates["{{PAGENAMEE}}"] = mw.uri.encode(title.text, "WIKI")
				templates["{{BASEPAGENAMEE}}"] = mw.uri.encode(title.baseText, "WIKI")
				templates["{{SUBPAGENAMEE}}"] = mw.uri.encode(title.subpageText, "WIKI")
				templates["{{FULLPAGENAME}}"] = title.fullText
				templates["{{PAGENAME}}"] = title.text
				templates["{{BASEPAGENAME}}"] = title.baseText
				templates["{{SUBPAGENAME}}"] = title.subpageText
				templates[resources.data.pageUrlTemplate] = title:fullUrl()
				templates["{{Cat}}"] = resources.data.defaultcategory
 				templates[resources.data.talkSectionTemplate] = pf.args[resources.data.talkPageSectionParamIndex] or ""
				local defaultComment, _ = string.gsub(c.default or "", resources.data.templatePattern, templates)
				templates[resources.data.infoTemplate] = ((comments)and(#comments > 0)) and ((c.prefix or "")..table.concat(comments, c.separator or ", ")..(c.suffix or "")) or defaultComment
				templates[resources.data.infoTemplate]=string.gsub(templates[resources.data.infoTemplate],resources.data.templatePattern,templates);
				-- prepare "talk" hint
				local talk = ""
				if title.talkPageTitle and title.talkPageTitle.exists then
					talk, _ = string.gsub(reason.talk or "", resources.data.templatePattern, templates)
				end
				templates[resources.data.talkTemplate] = talk
			    	return templates
		    	end
		    	
	    		sekcja=pf.args[resources.data.sectionParamIndex];

		    	local defaultDate = pf.args[resources.data.defaultDateIndex] or ""

		    	local complexCategories = {
			    	categories = function(result, date)
--						 if (switch == resources.data.defaulthelp) or (switch == "Wikipedia") or (switch == "Portal") or (switch == "Wikiproject") then
--							table.insert(result, "[[Kategoria:WP?|"..title.text.."]]")
--						else
						table.insert(result, "[[{{Cat}}:{{unit type}} wymagające umieszczenia w odpowiedniej kategorii|"..title.text.."]]")
					end,}
		    	local mapParamToReason = {}
		    	for i, v in ipairs(resources.reasons) do
			    	for _, a in ipairs(v.aliases) do
				    	mapParamToReason[a] = i
			    	end
		    	end

		    	local reasonDates = {}
		    -- scan well known reasons with date
		    	for k, i in pairs(mapParamToReason) do
		  	    	local object = pf:getArgument(k)
			    	if object then
				    	 local currentDate = object:expand()
				    	 if currentDate then
					    	local previousDate = reasonDates[i]
					    	if not previousDate or (previousDate == "") or ((currentDate ~= "") and (currentDate < previousDate)) then
								reasonDates[i] = currentDate
					    	end
				    	end
			    	end
		    	end

		    	local onlyReason = nil
		    	local allMessages = {}
		    	local customMessages = {}

				-- collect messages with dates
				for i, v in ipairs(resources.reasons) do
					local date = reasonDates[i]
					if date then
						table.insert(allMessages, (#date > 0) and string.format(resources.data.messageWithDatePrefix, date, v.message) or v.message)
						if not onlyReason then
							onlyReason = i
						else
							onlyReason = 0
						end
					end
				end

			-- scan reasons without dates
				local scanReasonWithoutDate = function(index,reason)
				   if reason then
					    reason = mw.text.trim(reason)
					    if (index ~= resources.data.sectionParamIndex) or (reason ~= resources.data.sectionParamValue) then
						   if #reason > 0 then
							   local known = mapParamToReason[reason]
							   if not known then
								   table.insert(allMessages, reason)
								   table.insert(customMessages, reason)
							   else
								  if not onlyReason then
									  onlyReason = known
								  elseif onlyReason ~= known then
									  onlyReason = 0
								  end
								  if not reasonDates[known] then
									  reasonDates[known] = defaultDate
									  local v = resources.reasons[known].message
									  table.insert(allMessages, (#defaultDate > 0) and string.format(resources.data.messageWithDatePrefix, defaultDate, v) or v)
								  end
							   end
						   end
					    end
				    end
				 return reason
			   --end
		    end
		    local sectionParam = scanReasonWithoutDate(resources.data.sectionParamValue)
		    for i, reason in ipairs(pf.args) do
		    	if(type(i)=="number")then
			       scanReasonWithoutDate(i,reason)
			    end
		    end
		   local categories = {}
		   local bezkategorii=pf.args["bez kategorii"];
		   if((bezkategorii==nil)or(bezkategorii==""))then
		       for i, v in ipairs(resources.reasons) do
			       local date = reasonDates[i]
			       if date and v.cat then
				      local complexCat = complexCategories[v.cat]
				      if complexCat then
					      complexCat(categories, date)
				      else
			            	table.insert(categories, (v.catDate and (#date > 0)) and string.format(v.catDate, date) or v.cat)
				      end;
			      end
		        end
		       if (#categories == 0)then
			       table.insert(categories, resources.default.cat)
               end
           end
		-- prepare date hints
		    local hints = {}
		    local currentDate = nil
		    for i, v in ipairs(resources.reasons) do
			    local date = reasonDates[i]
			    if date and (#date == 0) and v.catDate then
				   if not currentDate then
					   currentDate = mw.getContentLanguage():formatDate(resources.data.dateFormat, nil, true)
				   end
				   table.insert(hints, string.format(resources.data.dateExample, v.aliases[1], currentDate))
			    end
		    end

	 	    local result = {}
		    local section = (sekcja == resources.data.sectionParamValue) or sectionParam
		    local onlyReasonData = resources.reasons[onlyReason]
		    local mainText = nil
		    local templates = {}
		    if onlyReasonData and onlyReasonData.simple and ((#customMessages == 0) or onlyReasonData["?"]) then
			    local date = reasonDates[onlyReason]
			    if #date > 0 then
				   date = string.format(resources.data.dateInfix, date)
			    end
			   templates = prepareTemplates(onlyReasonData, date, section, customMessages)
			   mainText, _ = string.gsub(onlyReasonData.simple, resources.data.templatePattern, templates)
		   end
		   if not mainText and not onlyReason then
		     	 local date = pf.args[resources.data.defaultDateIndex] or ""
			     if #date > 0 then
				    date = string.format(resources.data.dateInfix, date)
			     end
			     templates = prepareTemplates(resources.default, date, section, customMessages)
			     mainText, _ = string.gsub(resources.default.simple, resources.data.templatePattern, templates)
		    end
		    if not mainText then
			     templates = prepareTemplates(resources.default, "", section, allMessages)
			     mainText, _ = string.gsub(resources.default.message, resources.data.templatePattern, templates)
 		    end
 		    
 		     table.insert(result, mainText)
 		     if title.talkPageTitle and title.talkPageTitle.exists and ((#templates[resources.data.talkTemplate] == 0) or (#templates[resources.data.talkSectionTemplate] > 0))  then
	 		     local talkPageMessage, _ = string.gsub((#templates[resources.data.talkSectionTemplate] == 0) and resources.data.talkPage or resources.data.talkSection, resources.data.templatePattern, templates)
 			     table.insert(result, talkPageMessage)
	 	     end
	 	    local articleInstruction, _ = string.gsub(resources.data.articleInstruction, resources.data.templatePattern, templates)
	 	    table.insert(result, articleInstruction)
		    if #hints > 0 then
		 	    table.insert(result, string.format(resources.data.templateInstruction, table.concat(hints, ", ")))
		    end
		    local categor=table.concat(categories,"")
		    categor=string.gsub(categor,resources.data.templatePattern,templates)
            table.insert(result, categor)
		    local result = table.concat(result, "")
            return NoweZwrocone(result)
	end,
}