Module:Lang/documentor tool

require('Module:No globals'); local p = {};

--[[-< L A N G - X X _ S E T T I N G S >-

Reads the content of the template and extracts the parameters from for display on the template's documentation page.

]]

local function lang_xx_settings (frame) local page = mw.title.makeTitle ('Template', frame.args['template'] or frame.args[1]);	-- get a page object for this page in 'Template:' namespace if not page then return '';																-- TODO: error message? end local content = page:getContent;											-- get unparsed content if not page then return '';																-- TODO: error message? end

local out = {}; local params; local style;

if content:match ('{{%s*#invoke:%s*[Ll]ang%s*|[^|]+|[^}]+}}') or content:match ('{{%s*#invoke:%s*[Ll]ang/sandbox%s*|[^|]+|[^}]+}}') then			-- if this template uses Module:Lang params = content:match ('{{%s*#invoke:%s*[Ll]ang%s*|[^|]+(|[^}]+)}}') or content:match ('{{%s*#invoke:%s*[Ll]ang/sandbox%s*|[^|]+(|[^}]+)}}')	-- extract the #invoke:'s parameters if not params then return '';															-- there should be at least one or the template/module won't work TODO: error message? end table.insert (out, '{| class="wikitable" style="text-align:right; float:right"\n|+settings')	-- start a wikitable for k, v in params:gmatch ('%s*|%s*([^%s=]+)%s*=%s*([^%s|]+)') do		-- get the parameter names (k) and values (v) if 'label' == k then												-- special case for labels because spaces and pipes v = params:match ('label%s*=%s*(%[%^%+%]%])') or params:match ('label%s*=%s*([^|\n]+)') or 'missing label'; end table.insert (out, table.concat ({k, '\n|', v}));					-- make rudimentary wikitable entries end

style = content:match ('lang_xx_([^|]+)'); return table.concat ({table.concat (out,'\n|-\n! scope="row" | '), '\n|-\n|colspan="2"|style: ', style, '\n|-\n|}'});	-- add inter-row markup and close the wikitable and done else return '';																-- does not use Module:Lang so abandon quietly end end

--[[-< U S E S _ M O D U L E >-

Reads the content of the template to determine if this template uses Module:Lang. Returns the index of the substring '{{#invoke|lang|' in the template page content if true; empty string if false.

Used in template documentation {{#if:}} parser functions.

]]

local function uses_module (frame) local page = mw.title.makeTitle ('Template', frame.args['template'] or frame.args[1]);	-- get a page object for this page in 'Template:' namespace if not page then return '';																-- TODO: error message? end local content = page:getContent;											-- get unparsed content if not page then return '';																-- TODO: error message? end return content:find ('{{%s*#invoke:[Ll]ang%s*|') or '';						-- return index or empty string end

--[[-< S H A R E D _ C O D E >-

- Tables: -- language_categories -- error_messages

- Functions: -- get_error_message(message) -- get_see_also_section(page_title, language_name, language_code) -- get_top_section(frame) -- get_bottom_section(frame, language_name, see_also_section, parent_category)

]]

local language_categories = { ["LANGUAGES_SOURCES"] = "Articles with %s-language sources (%s)", ["LANGUAGES_COLLECTIVE_SOURCES"] = "Articles with %s-collective sources (%s)", ["CS1"] = "CS1 %s-language sources (%s)", ["LANGUAGE_TEXT"] = "Articles containing %s-language text", -- old version ["LANGUAGES_COLLECTIVE_TEXT"] = "Articles with text from the %s collective", ["LANGUAGES_COLLECTIVE_TEXT"] = "Articles with text in %s", ["ENGLISH"] = "Articles containing explicitly cited %s-language text", }

local error_messages = { ["NOT_VALID_LANGUAGE_CODE"] = "%s is not a valid ISO 639 or IETF language name.", ["NO_CATEGORY_TITLE_FOUND"] = "No language category found for %s.", ["INCORRECT_CATEGORY_TITLE"] = "%s is not the category being populated by the {{%s}} template. The correct category is located at: %s.", }

local function get_error_message(message) return string.format(' Error: %s ', message) end

local function get_language_link(language_name, language_code) local lang_module = require('Module:Lang') -- Is a language collective? if language_name:find('languages') then return lang_module.name_from_tag({language_code, link = "yes"}) else return lang_module.name_from_tag({language_code, link = "yes", label = lang_module.name_from_tag({language_code}) .. "-language"}) end end

-- Generates a consistent style See also section for {{Category articles containing non-English-language text}} and {{Non-English-language source category}}. -- If {{CS1 language sources}} is converted, it should also use it. local function get_see_also_section(page_title, language_name, language_code) local see_also_section = {}

for _, category_name in pairs(language_categories) do   	local category = mw.title.new(string.format(category_name, language_name, language_code), 14) if category and page_title ~= category.text and category.exists then table.insert(see_also_section, "* " .. category.prefixedText .. "") end end table.sort(see_also_section) table.insert(see_also_section, 1, '\n\n==See also==') if table.getn(see_also_section) == 1 then return "" else return table.concat(see_also_section, "\n") end end

local function get_hidden_category_template(frame) return frame:expandTemplate{title = 'Hidden category'} end

-- Generates a consistent top maintenance template section. local function get_top_section(frame) local top_section = {} if mw.site.stats.pagesInCategory(mw.title.getCurrentTitle.text, "all") == 0 then table.insert(top_section, frame:expandTemplate{title = 'Possibly empty category'}) else table.insert(top_section, frame:expandTemplate{title = 'Possibly empty category', args = {hidden=true}}) end

local purge_module = require('Module:Purge') table.insert(top_section, ' ' .. purge_module._main({"Purge page cache"}) .. ' ') return table.concat(top_section, "\n\n") end

-- Generates a consistent non-text section. local function get_bottom_section(frame, language_name, see_also_section, parent_category) local bottom_section = {} table.insert(bottom_section, frame:expandTemplate{title = 'CatAutoTOC'}) table.insert(bottom_section, see_also_section) table.insert(bottom_section, frame:preprocess{text = "{{DEFAULTSORT:" .. language_name .. "}}"}) if mw.title.getCurrentTitle.nsText == "Category" then table.insert(bottom_section, parent_category) end

return table.concat(bottom_section, "\n\n\n") end

--[[-< N O N _ E N G L I S H _ L A N G U A G E _ T E X T _ C A T E G O R Y >-

{{#invoke:Lang/documentor tool|non_english_language_text_category}}

This function implements {{Non-English-language text category}}. ]]

local non_english_language_text_text_strings = { ["LINE1"] = "This category contains articles with %s%s text. The primary purpose of these categories is to facilitate manual or automated checking of text in other languages.", ["LINE2"] = "This category should only be added with the %s family of templates, never explicitly.", ["LINE3"] = 'For example %s, which wraps the text with .%s', ["LINE3_EXTRA"] = " Also available is %s which displays as %s.", ["IN_SCRIPT"] = " (in %s)", ["EXAMPLE_DEFAULT_TEXT"] = "text in %s language here", ["PARENT_CATEGORY"] = "", }

local function non_english_language_text_category(frame) local args = require('Module:Arguments').getArgs(frame) local page_title = mw.title.getCurrentTitle.text

-- Naming style: Articles with text from the Berber languages collective local page_title_modified = page_title local split_title = "([^,]+)%%s([^,]+)" local part1 = "" local part2 = ""

if page_title_modified:find('Articles with text in') then -- Naming style: Category:Articles with text from Afro-Asiatic languages (as currently implemented in Module:lang) part1, part2 = language_categories["LANGUAGES_COLLECTIVE_TEXT"]:match(split_title) elseif page_title_modified:find('explicitly cited') then part1, part2 = language_categories["ENGLISH"]:match(split_title) else -- Naming style: Category:Articles containing French-language text part1, part2 = language_categories["LANGUAGE_TEXT"]:match(split_title) end

page_title_modified = page_title_modified:gsub(part1, "") page_title_modified = page_title_modified:gsub(part2, "") local language_name = page_title_modified

local lang_module = require('Module:Lang') local language_code = lang_module._tag_from_name({language_name})

local layout = {} table.insert(layout, get_hidden_category_template(frame)) local see_also_section = "" -- Check if error message if language_code:find('error') then table.insert(layout, get_error_message(string.format(error_messages["NOT_VALID_LANGUAGE_CODE"], language_name))) else local correct_language_category_title = lang_module._category_from_tag({language_code}) if correct_language_category_title:find('error') then table.insert(layout, get_error_message(string.format(error_messages["NO_CATEGORY_TITLE_FOUND"], language_code))) else local current_category_title = mw.title.getCurrentTitle.prefixedText if current_category_title ~= correct_language_category_title then table.insert(layout, get_error_message(string.format(error_messages["INCORRECT_CATEGORY_TITLE"], current_category_title, "Lang", correct_language_category_title))) else table.insert(layout, get_top_section(frame)) local script = args.script local script_text if script then script_text = string.format(non_english_language_text_text_strings["IN_SCRIPT"], script) else script_text = "" end local example_default_text = string.format(non_english_language_text_text_strings["EXAMPLE_DEFAULT_TEXT"], language_name) local example_text = args.example or example_default_text

local language_link = get_language_link(language_name, language_code)

table.insert(layout, string.format(non_english_language_text_text_strings["LINE1"], language_link, script_text)) local lang_template = frame:expandTemplate{title = 'Tl', args = {"Lang"}} table.insert(layout, string.format(non_english_language_text_text_strings["LINE2"], lang_template))

local language_code_link = lang_module._name_from_tag({language_code, link="yes", label=language_code}) local lang_template_example = frame:expandTemplate{title = 'Tlx', args = {"Lang", language_code_link, example_text}} local lang_x = mw.title.makeTitle(10, "Lang-" .. language_code) local line3_extra = "" if lang_x.exists then local lang_x_template_example = frame:expandTemplate{title = 'Tlx', args = {lang_x.text, example_text}} local lang_x_template = frame:expandTemplate{title = lang_x.text, args = {example_text}} line3_extra = string.format(non_english_language_text_text_strings["LINE3_EXTRA"], lang_x_template_example, lang_x_template) end table.insert(layout, string.format(non_english_language_text_text_strings["LINE3"], lang_template_example, language_code, line3_extra)) see_also_section = get_see_also_section(page_title, language_name, language_code) end end end local bottom = get_bottom_section(frame, language_name, see_also_section, non_english_language_text_text_strings["PARENT_CATEGORY"]) return table.concat(layout, "\n\n") .. bottom end

--[[-< N O N _ E N G L I S H _ L A N G U A G E _ S O U R C E S _ C A T E G O R Y >-

{{#invoke:Lang/documentor tool|non_english_language_sources_category}}

This function implements {{Non-English-language sources category}}.

]]

local non_english_language_sources_text_strings = { ["LINE1"] = "This is a tracking category for articles that use %s to identify %s sources.", ["PARENT_CATEGORY"] = "", }

local function non_english_language_sources_category(frame) local page_title_object = mw.title.getCurrentTitle local page_title = page_title_object.text local language_code = page_title:match('%(([%a%-]+)%)') local language_name = require('Module:Lang')._name_from_tag({language_code})

local layout = {} table.insert(layout, get_hidden_category_template(frame)) local see_also_section = "" local current_category_title = page_title_object.prefixedText local correct_language_category_title = require('Module:In lang')._in_lang({language_code, ["list-cats"]="yes"}) if correct_language_category_title == "" then table.insert(layout, get_error_message(string.format(error_messages["NO_CATEGORY_TITLE_FOUND"], language_code))) elseif correct_language_category_title ~= current_category_title then table.insert(layout, get_error_message(string.format(error_messages["INCORRECT_CATEGORY_TITLE"], current_category_title, "In lang", correct_language_category_title))) else local language_link = get_language_link(language_name, language_code) local text = string.format(non_english_language_sources_text_strings["LINE1"], frame:expandTemplate{title = 'Tlx', args = {"In lang", language_code}}, language_link) table.insert(layout, get_top_section(frame)) table.insert(layout, text) see_also_section = get_see_also_section(page_title, language_name, language_code) end

local bottom = get_bottom_section(frame, language_name, see_also_section, non_english_language_sources_text_strings["PARENT_CATEGORY"]) return table.concat(layout, "\n\n") .. bottom end

--[[-< N O N _ E N G L I S H _ L A N G U A G E _ C S 1 _ S O U R C E S _ C A T E G O R Y >-

{{#invoke:Lang/documentor tool|non_english_language_cs1_sources_category}}

This function implements {{Non-English-language CS1 sources category}}. ]]

local non_english_language_cs1_text_strings = { ["LINE1"] = "This is a tracking category for CS1 citations that use the parameter %s to identify a source in %s. Pages in this category should only be added by CS1 templates and Module:Citation/CS1.", ["PARENT_CATEGORY"] = "", -- #TODO change to "Articles with non-english CS1 language sources" or "CS1 non-English language sources" }

--"This is a tracking category for CS1 citations that use the parameter %s to hold a citation title that uses %s characters and contains the language prefix . Pages in this category should only be added by CS1 templates and Module:Citation/CS1.", --"",	-- "This is a tracking category for CS1 citations that use the parameter %s. Pages in this category should only be added by CS1 templates and Module:Citation/CS1.", -- "to identify a source in %s.", -- "to hold a citation title that uses %s characters and contains the language prefix .",

local function non_english_language_cs1_sources_category(frame) local page_title_object = mw.title.getCurrentTitle local page_title = page_title_object.text local language_code = page_title:match('%(([%a%-]+)%)') local language_name = require('Module:Lang')._name_from_tag({language_code}) local layout = {} table.insert(layout, get_hidden_category_template(frame)) local see_also_section = "" local parameter_doc = frame:expandTemplate{title = 'para', args = {"language", language_code}} table.insert(layout, get_top_section(frame)) table.insert(layout, string.format(non_english_language_cs1_text_strings["LINE1"], parameter_doc, language_name, language_name)) local see_also_section = get_see_also_section(page_title, language_name, language_code) local bottom = get_bottom_section(frame, language_name, see_also_section, non_english_language_cs1_text_strings["PARENT_CATEGORY"]) return table.concat(layout, "\n\n") .. bottom end

---< T E S T _ C A S E S _ S H A R E D _ C O D E >-

local function compare_by_keys2(a, b)											-- local function used by table.sort return a[2] < b[2]															-- ascending sort by code end

local function compare_by_keys(a, b)											-- local function used by table.sort return a[1] < b[1]															-- ascending sort by code end

-- Used by testcases_iso_code_to_name local function get_language_code_table_from_code(args) local entry = {} --if args.override_table[args.language_code] then --	table.insert(entry, args.override_table[args.language_code][1]) -- :gsub(' %b$', '') fails here --else table.insert(entry, args.language_code) --	end return entry end

-- Used by testcases_name_from_tag local function get_language_code_and_name_table_from_code(args) local entry = {} if args.override_table[args.language_code] then table.insert(entry, args.language_code) local language_code, _ = args.override_table[args.language_code][1]:gsub(' %b$', '') table.insert(entry, language_code) else table.insert(entry, args.language_code) table.insert(entry, args.language_table[args.language_code]) end return entry end

-- Used by testcases_category_from_tag local function get_language_code_and_category_table_from_code(args) local entry = {} table.insert(entry, args.language_code) table.insert(entry, args.test_function({args.language_code})) return entry end

-- Used by testcases_iso_name_to_code and testcases_tag_from_name local function get_language_name_and_code_table_from_code(args) local entry = {} if args.override_table[args.language_code] then table.insert(entry, args.override_table[args.language_code][1])			-- only the first name when there are multiples table.insert(entry, args.language_code) else table.insert(entry, args.language_names[1])								-- only the first name when there are multiples table.insert(entry, args.language_code) end return entry end

local function get_table(table_function, language_table, length, range, iso_number, test_function) local table_of_language_name_and_code_tables = {}

local override_table_name = "override" if iso_number then override_table_name = "override_" .. iso_number end local override_table = require("Module:Language/data/ISO_639_override/sandbox")[override_table_name] -- For most ISO 639s. if range then for language_code, language_names in pairs(language_table) do			if language_code:find(range) then table.insert(table_of_language_name_and_code_tables, table_function({ override_table = override_table, language_code = language_code, language_names = language_names, test_function = test_function, language_table = language_table }))			end end -- For ISO 639-1. elseif length then for language_code, language_names in pairs(language_table) do			if language_code:len == 2 then table.insert(table_of_language_name_and_code_tables, table_function({ override_table = override_table, language_code = language_code, language_names = language_names, test_function = test_function, language_table = language_table }))			end end -- For general /testcases. else for language_code, language_names in pairs(language_table) do				table.insert(table_of_language_name_and_code_tables, table_function({ override_table = override_table, language_code = language_code, language_names = language_names, test_function = test_function, language_table = language_table }))		end end return table_of_language_name_and_code_tables end

local function get_undabbed_table(language_list, length, range) local undabbed_language_table = {}											-- for this test, ISO 639-3 language name disambiguators must be removed; un-dabbed names go here for language_code, language_names in pairs(language_list) do -- For most ISO 639s. if range then if language_code:find(range) then undabbed_language_table[language_code] = language_names[1]:gsub(' %b$', '')	-- undab and save only the first name; ignore all other names assigned to a code end -- For ISO 639-1. elseif length then if language_code:len == 2 then undabbed_language_table[language_code] = language_names[1]:gsub(' %b$', '')	-- undab and save only the first name; ignore all other names assigned to a code end -- For general /testcases. else undabbed_language_table[language_code] = language_names[1]:gsub(' %b$', '') end end return undabbed_language_table end

--[[-< T E S T C A S E S _ C A T E G O R Y _ F R O M _ T A G >-

Entry point for the various category_from_tag testcases.

Build a table of test patterns where each entry in the table is a table with two members: {"", ""}

- "Expected" column value is the category name according to Module:Lang. - "Actual" column value is the result of {{#invoke:Lang/sandbox|category_from_tag|}}.

TODO: Currently not working. ]]

local function testcases_category_from_tag(self, args) local cat_from_tag_function = require('Module:Lang')._category_from_tag local language_tables = get_table(get_language_code_and_category_table_from_code, args.language_list, args.length, args.range, args.iso_number, cat_from_tag_function) table.sort(language_tables, compare_by_keys)

self:preprocess_equals_preprocess_many(   	'{{#invoke:Lang/sandbox|category_from_tag|', '}}', , ,		language_tables, 		{nowiki=false}	) end

--[[-< T E S T C A S E S _ N A M E _ F R O M _ T A G >-

Entry point for the various name_from_tag testcases.

Build a table of test patterns where each entry in the table is a table with two members: {"", ""}

- "Expected" column value is the . - "Actual" column value is the result of sandbox version {{#invoke:Lang/sandbox|name_from_tag|}}. ]]

local function testcases_name_from_tag(self, args) local undabbed_language_table = get_undabbed_table(args.language_list, args.length, args.range, nil) local language_tables = get_table(get_language_code_and_name_table_from_code, undabbed_language_table, args.length, args.range) table.sort(language_tables, compare_by_keys)

self:preprocess_equals_preprocess_many(   	'{{#invoke:Lang/sandbox|name_from_tag|', '}}', , ,		language_tables, 		{nowiki=false}	) end

--[[-< T E S T C A S E S _ T A G _ F R O M _ N A M E >-

Entry point for the various tag_from_name testcases.

Build a table of test patterns where each entry in the table is a table with two members: {"", ""}

- "Expected" column value is the . - "Actual" column value is the result of sandbox version {{#invoke:Lang/sandbox|tag_from_name|}}.

TODO: Currently not working. ]]

local function testcases_tag_from_name(self, args) local language_tables = get_table(get_language_name_and_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil) table.sort(language_tables, compare_by_keys2)

local ordered_table = {} table.sort(unordered_table) for _, key in ipairs(unordered_table) do		table.insert(ordered_table, {key, reverse_table[key]}) end

self:preprocess_equals_preprocess_many(   	'{{#invoke:Lang/sandbox|tag_from_name|', '}}', , ,		language_tables, 		{nowiki=false}	) end

--[[-< T E S T C A S E S _ I S O _ C O D E _ T O _ N A M E >-

Entry point for the various iso_code_to_name testcases.

Build a table of test patterns where each entry in the table is a table with one member: {""}

- "Expected" column value is the result of the live version of {{#invoke:ISO 639 name|iso_639_name_to_code|}}. - "Actual" column value is the result of sandbox version {{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|}}. ]]

local function testcases_iso_code_to_name(self, args) local language_tables = get_table(get_language_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil) table.sort(language_tables, compare_by_keys)

self:preprocess_equals_preprocess_many(   	'{{#invoke:ISO 639 name/sandbox|iso_639_code_to_name|link=yes|', '}}', '{{#invoke:ISO 639 name|iso_639_code_to_name|link=yes|', '}}',		language_tables, 		{nowiki=false}	) end

--[[-< T E S T C A S E S _ I S O _ N A M E _ T O _ C O D E >-

Entry point for the various iso_name_to_code testcases.

Build a table of test patterns where each entry in the table is a table with two members: {"", ""}

- "Expected" column value is the <language_code>. - "Actual" column is value the result of {{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|<language_name>}}. ]]

local function testcases_iso_name_to_code(self, args) local language_tables = get_table(get_language_name_and_code_table_from_code, args.language_list, args.length, args.range, args.iso_number, nil) table.sort(language_tables, compare_by_keys2) self:preprocess_equals_preprocess_many(   	'{{#invoke:ISO 639 name/sandbox|iso_639_name_to_code|2=' .. args.iso_number .. "|", '}}', , ,		language_tables, 		{nowiki=false}	) end

---< E X P O R T E D  F U N C T I O N S >-

return { lang_xx_settings = lang_xx_settings, uses_module = uses_module, non_english_language_text_category = non_english_language_text_category, non_english_language_sources_category = non_english_language_sources_category, non_english_language_cs1_sources_category = non_english_language_cs1_sources_category,

-- Module:Lang testcases testcases_category_from_tag = testcases_category_from_tag, testcases_name_from_tag = testcases_name_from_tag, testcases_tag_from_name = testcases_tag_from_name,

-- Module:ISO 639 name testcases testcases_iso_code_to_name = testcases_iso_code_to_name, testcases_iso_name_to_code = testcases_iso_name_to_code, }