|
|
(6 intermediate revisions by 4 users not shown) |
Line 1: |
Line 1: |
| --[=[ | | --[=[ |
|
| |
|
| Lua support for the {{lang}}, {{lang-xx}}, and {{transl}} templates and replacement of various supporting templates. | | Lua support for the {{lang}}, {{lang-xx}}, and {{transliteration}} templates and replacement of various supporting templates. |
|
| |
|
| ]=] | | ]=] |
|
| |
|
| require('Module:No globals'); | | require('strict'); |
|
| |
|
| local getArgs = require ('Module:Arguments').getArgs; | | local getArgs = require ('Module:Arguments').getArgs; |
Line 25: |
Line 25: |
| local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization | | local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization |
|
| |
|
| local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language | | local content_lang = mw.language.getContentLanguage(); |
| | local this_wiki_lang_tag = content_lang.code; -- get this wiki's language tag |
| | local this_wiki_lang_dir = content_lang:getDir(); -- get this wiki's language direction |
|
| |
|
| local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic() | | local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic() |
Line 103: |
Line 105: |
| The return value nil causes the calling lang, lang_xx, or transl function to set args.italic according to the template's | | The return value nil causes the calling lang, lang_xx, or transl function to set args.italic according to the template's |
| defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on | | defined default ('inherit' for {{lang}}, 'inherit' or 'italic' for {{lang-xx}} depending on |
| the individual template's requirements, 'italic' for {{transl}}) or to the value appropriate to |script=, if set ({{lang}} | | the individual template's requirements, 'italic' for {{transliteration}}) or to the value appropriate to |script=, if set ({{lang}} |
| and {{lang-xx}} only). | | and {{lang-xx}} only). |
|
| |
|
Line 412: |
Line 414: |
| local category; | | local category; |
| | | |
| if 'Transl' == template then | | if 'Transliteration' == template then |
| category = 'Transl'; | | category = 'Transliteration'; |
| else | | else |
| category = 'Lang and lang-xx' | | category = 'Lang and lang-xx' |
Line 419: |
Line 421: |
| | | |
| table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available | | table.insert (out, table.concat ({'[', args.text or 'undefined', '] '})); -- for error messages output args.text if available |
| table.insert (out, table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: {{', template, '}}: '})); | | table.insert (out, table.concat ({'<span style=\"color:#d33\">Error: {{', template, '}}: '})); |
| table.insert (out, msg); | | table.insert (out, msg); |
| table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); | | table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'})); |
| table.insert (out, '</span>'); | | table.insert (out, '</span>'); |
| | | |
| if (0 == namespace or 10 == namespace) and not args.nocat then -- categorize in article space (and template space to take care of broken usages) | | if (0 == namespace or 10 == namespace) and not args.nocat then -- categorize in article space (and template space to take care of broken usages) |
| table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); | | table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'})); |
| end | | end |
Line 464: |
Line 466: |
| if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text | | if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text |
| if 'italic' == style then | | if 'italic' == style then |
| return mw.ustring.gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item | | return text:gsub ('(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item |
| else | | else |
| return text; | | return text; |
Line 482: |
Line 484: |
|
| |
|
| return text; | | return text; |
| | end |
| | |
| | |
| | --[[--------------------------< T I T L E _ W R A P P E R _ M A K E >------------------------------------------ |
| | |
| | makes a <span title="<title text>"><content_text></span> or <div title="<title text>"><content_text></div> where |
| | <title text> is in the tool-tip in the wiki's local language and <content_text> is non-local-language text in |
| | html markup. This because the lang= attibute applies to the content of its enclosing tag. |
| | |
| | <tag> holds a string 'div' or 'span' used to choose the correct wrapping tag |
| | ]] |
| | |
| | local function title_wrapper_make (title_text, content_text, tag) |
| | local wrapper_t = {}; |
| | |
| | table.insert (wrapper_t, table.concat ({'<', tag})); -- open opening wrapper tag |
| | table.insert (wrapper_t, ' title=\"'); -- begin title attribute |
| | table.insert (wrapper_t, title_text); -- add <title_text> |
| | table.insert (wrapper_t, '\">'); -- end title attribute and close opening wrapper tag |
| | table.insert (wrapper_t, content_text); -- add <content_text> |
| | table.insert (wrapper_t, table.concat ({'</', tag, '>'})); -- add closing wrapper tag |
| | |
| | return table.concat (wrapper_t); -- make a big string and done |
| end | | end |
|
| |
|
Line 489: |
Line 514: |
| Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or | | Add the html markup to text according to the type of content that it is: <span> or <i> tags for inline content or |
| <div> tags for block content | | <div> tags for block content |
| | |
| | The lang= attribute also applies to the content of the tag where it is placed so this is wrong because 'Spanish |
| | language text' is English: |
| | <i lang="es" title="Spanish language text">casa</i> |
| | should be: |
| | <span title="Spanish language text"><i lang="es">casa</i></span> |
| | or for <div>...</div>: |
| | <div title="Spanish language text"><div lang="es"><spanish-language-text></div></div> |
|
| |
|
| ]] | | ]] |
|
| |
|
| local function make_text_html (code, text, tag, rtl, style, size, language) | | local function make_text_html (code, text, tag, rtl, style, size, language) |
| local html = {}; | | local html_t = {}; |
| local style_added = ''; | | local style_added = ''; |
| | local wrapper_tag = tag; -- <tag> gets modified so save a copy for use when/if we create a wrapper span or div |
|
| |
|
| if text:match ('^%*') then | | if text:match ('^%*') then |
| table.insert (html, '*'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki | | table.insert (html_t, '*'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plain splat confuses MediaWiki |
| text = text:gsub ('^%*', ''); -- remove the splat from the text | | text = text:gsub ('^%*', ''); -- remove the splat from the text |
| end | | end |
Line 509: |
Line 543: |
| end | | end |
|
| |
|
| table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag | | table.insert (html_t, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag |
| code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia | | code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia |
| table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute | | table.insert (html_t, table.concat ({' lang="', code, '\"'})); -- add language attribute |
|
| |
|
| if rtl or unicode.is_rtl(text) then | | if (rtl or unicode.is_rtl(text)) and ('ltr' == this_wiki_lang_dir) then -- text is right-to-left on a left-to-right wiki |
| table.insert (html, ' dir="rtl"'); -- add direction attribute for right to left languages | | table.insert (html_t, ' dir="rtl"'); -- add direction attribute for right-to-left languages |
| | elseif not (rtl or unicode.is_rtl(text)) and ('rtl' == this_wiki_lang_dir) then -- text is left-to-right on a right-to-left wiki |
| | table.insert (html_t, ' dir="ltr"'); -- add direction attribute for left-to-right languages |
| end | | end |
|
| |
|
| if 'normal' == style then -- when |italic=no | | if 'normal' == style then -- when |italic=no |
| table.insert (html, ' style=\"font-style: normal;'); -- override external markup, if any | | table.insert (html_t, ' style=\"font-style: normal;'); -- override external markup, if any |
| style_added = '\"'; -- remember that style attribute added and is not yet closed | | style_added = '\"'; -- remember that style attribute added and is not yet closed |
| end | | end |
Line 524: |
Line 560: |
| if is_set (size) then -- when |size=<something> | | if is_set (size) then -- when |size=<something> |
| if is_set (style_added) then | | if is_set (style_added) then |
| table.insert (html, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted | | table.insert (html_t, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted |
| else | | else |
| table.insert (html, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute | | table.insert (html_t, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute |
| style_added = '\"'; -- remember that style attribute added and is not yet closed | | style_added = '\"'; -- remember that style attribute added and is not yet closed |
| end | | end |
| end | | end |
|
| |
|
| if is_set (language) then | | table.insert (html_t, table.concat ({style_added, '>'})); -- close the opening html tag |
| table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text
| | table.insert (html_t, text); -- insert the text |
| if language:find ('languages') then
| | |
| table.insert (html, ' collective text'); -- for collective languages
| | table.insert (html_t, table.concat ({'</', tag, '>'})); -- close the 'text' <i>, <span>, or <div> html tag |
| else
| |
| table.insert (html, '-language text'); -- for individual languages
| |
| end
| |
| table.insert (html, '\">'); -- close the opening html tag
| |
| else | |
| table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag
| |
| end
| |
| table.insert (html, text); -- insert the text
| |
|
| |
|
| table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag | | if is_set (language) then -- create a <title_text> string for the title= attribute in a wrapper span or div |
| | local title_text; |
| | if 'zxx' == code then -- special case for this tag 'no linguistic content' |
| | title_text = table.concat ({language, ' text'}); -- not a language so don't use 'language' in title text |
| | elseif mw.ustring.find (language, 'languages', 1, true) then |
| | title_text = table.concat ({language, ' collective text'}); -- for collective languages |
| | else |
| | title_text = table.concat ({language, '-language text'}); -- for individual languages |
| | end |
|
| |
|
| if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped inside an html tag with dir="rtl" attribute | | return title_wrapper_make (title_text, table.concat (html_t), wrapper_tag); |
| table.insert (html, '‎'); -- make sure the browser knows that we're at the end of the rtl | | else |
| | return table.concat (html_t); |
| end | | end |
| return table.concat (html); -- put it all together and done
| |
| end | | end |
|
| |
|
Line 574: |
Line 610: |
| end | | end |
|
| |
|
| if language_name:find ('languages') then | | if mw.ustring.find (language_name, 'languages', 1, true) then |
| return table.concat ({'[[Category:Articles with text in ', language_name, ']]'}); | | return table.concat ({'[[Category:Articles with text in ', language_name, ']]'}); |
| end | | end |
Line 580: |
Line 616: |
| table.insert (cat, '[[Category:Articles containing '); | | table.insert (cat, '[[Category:Articles containing '); |
|
| |
|
| if 'en' == code then | | if this_wiki_lang_tag == code then |
| table.insert (cat, 'explicitly cited ' .. language_name); -- falls back to English if regional name not available | | table.insert (cat, 'explicitly cited ' .. language_name); -- unique category name for the local language |
| else | | else |
| table.insert (cat, language_name); | | table.insert (cat, language_name); |
Line 596: |
Line 632: |
| return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string | | return translit <i lang=xx-Latn>...</i> where xx is the language code; else return empty string |
|
| |
|
| The value |script= is not used in {{transl}} for this purpose; instead it uses |code. Because language scripts | | The value |script= is not used in {{transliteration}} for this purpose; instead it uses |code. Because language scripts |
| are listed in the {{transl}} switches they are included in the data tables. The script parameter is introduced | | are listed in the {{transliteration}} switches they are included in the data tables. The script parameter is introduced |
| at {{Language with name and transliteration}}. If |script= is set, this function uses it in preference to code. | | at {{Language with name and transliteration}}. If |script= is set, this function uses it in preference to code. |
|
| |
|
Line 607: |
Line 643: |
| transl() always provides language_name, translit, and one of code or tscript, never both; always provides style | | transl() always provides language_name, translit, and one of code or tscript, never both; always provides style |
|
| |
|
| For {{transl}}, style only applies when a language code is provided | | For {{transliteration}}, style only applies when a language code is provided |
| ]] | | ]] |
|
| |
|
| local function make_translit (code, language_name, translit, std, tscript, style) | | local function make_translit (code, language_name, translit, std, tscript, style) |
| local title; | | local title; |
| local tout = {}; | | local out_t = {}; |
| local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards | | local title_t = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards |
| | | local title_text = ''; -- tool tip text for title= attribute |
| if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
| |
| if not style then -- nil for the default italic style
| |
| table.insert (tout, "<i lang=\""); -- so use <i> tag
| |
| else
| |
| table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it
| |
| end
| |
| table.insert (tout, code);
| |
| table.insert (tout, "-Latn\" title=\""); -- transliterations are always Latin script
| |
| else
| |
| table.insert (tout, "<span title=\""); -- when no language code: no lang= attribute, not italic ({{transl}} only)
| |
| end
| |
| | | |
| std = std and std:lower(); -- lower case for table indexing | | std = std and std:lower(); -- lower case for table indexing |
| | | |
| if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified | | if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified |
| table.insert (tout, language_name); -- write a generic tool tip | | title_text = language_name; -- write a generic tool tip |
| if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | | if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name) |
| table.insert (tout, '-language') -- skip this text (individual and macro languages only) | | title_text = title_text .. '-language'; -- skip this text (individual and macro languages only) |
| end | | end |
| table.insert (tout, ' romanization'); -- finish the tool tip; use romanization when neither script nor standard supplied | | title_text = title_text .. ' romanization'; -- finish the tool tip; use romanization when neither script nor standard supplied |
| | |
| elseif is_set (std) and is_set (tscript) then -- when both are specified | | elseif is_set (std) and is_set (tscript) then -- when both are specified |
| if title_table[std] then -- and if standard is legitimate | | if title_t[std] then -- and if standard is legitimate |
| if title_table[std][tscript] then -- and if script for that standard is legitimate | | if title_t[std][tscript] then -- and if script for that standard is legitimate |
| table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', script_table[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip | | if script_table[tscript] then |
| | title_text = title_text .. table.concat ({title_t[std][tscript:lower()], ' (', script_table[tscript], ' script) transliteration'}); -- add the appropriate text to the tool tip |
| | else |
| | title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? |
| | end |
| else | | else |
| table.insert (tout, title_table[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? | | title_text = title_text .. title_t[std]['default']; -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard? |
| end | | end |
| else | | else |
Line 647: |
Line 677: |
|
| |
|
| elseif is_set (std) then -- translit-script not set, use language code | | elseif is_set (std) then -- translit-script not set, use language code |
| if not title_table[std] then return ''; end -- invalid standard, setup for error message | | if not title_t[std] then return ''; end -- invalid standard, setup for error message |
| | | |
| if title_table[std][code] then -- if language code is in the table (transl may not provide a language code) | | if title_t[std][code] then -- if language code is in the table (transl may not provide a language code) |
| -- table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', lang_table[code][1], ' language) transliteration'})); -- add the appropriate text to the tool tip
| | title_text = title_text .. table.concat ({title_t[std][code:lower()], ' (', language_name, ' language) transliteration'}); -- add the appropriate text to the tool tip |
| table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', language_name, ' language) transliteration'})); -- add the appropriate text to the tool tip
| |
| else -- code doesn't match | | else -- code doesn't match |
| table.insert (tout, title_table[std]['default']); -- so use the standard's default | | title_text = title_text .. title_t[std]['default']; -- so use the standard's default |
| end | | end |
| | |
| else -- here if translit-script set but translit-std not set | | else -- here if translit-script set but translit-std not set |
| if title_table['no_std'][tscript] then | | if title_t['no_std'][tscript] then |
| table.insert (tout, title_table['no_std'][tscript]); -- use translit-script if set | | title_text = title_text .. title_t['no_std'][tscript]; -- use translit-script if set |
| elseif title_table['no_std'][code] then | | elseif title_t['no_std'][code] then |
| table.insert (tout, title_table['no_std'][code]); -- use language code | | title_text = title_text .. title_t['no_std'][code]; -- use language code |
| else | | else |
| if is_set (tscript) then | | if is_set (tscript) then |
| table.insert (tout, table.concat ({language_name, '-script transliteration'})); -- write a script tool tip | | title_text = title_text .. table.concat ({language_name, '-script transliteration'}); -- write a script tool tip |
| elseif is_set (code) then | | elseif is_set (code) then |
| if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name) | | if not mw.ustring.find (language_name, 'languages', 1, true) then -- collective language names (plural 'languages' is part of the name) |
| table.insert (tout, '-language') -- skip this text (individual and macro languages only) | | title_text = title_text .. '-language'; -- skip this text (individual and macro languages only) |
| end | | end |
| table.insert (tout, ' transliteration'); -- finish the tool tip | | title_text = title_text .. ' transliteration'; -- finish the tool tip |
| else | | else |
| table.insert (tout, ' transliteration'); -- generic tool tip (can we ever get here?) | | title_text = title_text .. ' transliteration'; -- generic tool tip (can we ever get here?) |
| end | | end |
| end | | end |
| end | | end |
|
| |
|
| table.insert (tout, '">'); | | local close_tag; |
| table.insert (tout, translit);
| | if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transliteration}}) |
| if is_set (code) and not style then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}}) | | code = code:match ('^(%a%a%a?)'); -- strip all subtags leaving only the language subtag |
| table.insert (tout, "</i>"); -- close the italic tag | | |
| | if not style then -- nil for the default italic style |
| | table.insert (out_t, "<i lang=\""); -- so use <i> tag |
| | close_tag = '</i>'; -- tag to be used when closing |
| | else |
| | table.insert (out_t, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it |
| | close_tag = '</span>'; -- tag to be used when closing |
| | end |
| | table.insert (out_t, code); |
| | table.insert (out_t, "-Latn\">"); -- transliterations are always Latin script |
| | else |
| | table.insert (out_t, "<span>"); -- when no language code: no lang= attribute, not italic ({{transliteration}} only) |
| | close_tag = '</span>'; |
| | end |
| | |
| | table.insert (out_t, translit); -- add the translit text |
| | table.insert (out_t, close_tag); -- and add the appropriate </i> or </span> |
| | |
| | if '' == title_text then -- when there is no need for a tool-tip |
| | return table.concat (out_t); -- make a string and done |
| else | | else |
| table.insert (tout, "</span>"); -- no language code so close the span tag | | return title_wrapper_make (title_text, table.concat (out_t), 'span'); -- wrap with a tool-tip span and don |
| end | | end |
| return table.concat (tout);
| |
| end | | end |
|
| |
|
Line 792: |
Line 840: |
| If text contains <poem>...</poem> stripmarker, return text unmodified and choose <div>..</div> tags because | | If text contains <poem>...</poem> stripmarker, return text unmodified and choose <div>..</div> tags because |
| the stripmarker is replaced with text wrapped in <div>..</div> tags. | | the stripmarker is replaced with text wrapped in <div>..</div> tags. |
| | |
| | If the text contains any actual <div>...</div> tags, then it's again returned unmodified and <div>...</div> |
| | tags are used to wrap it, to prevent div/span inversion. |
|
| |
|
| ]] | | ]] |
Line 800: |
Line 851: |
| if has_poem_tag (text) then -- contains poem stripmarker (we can't know the content of that) | | if has_poem_tag (text) then -- contains poem stripmarker (we can't know the content of that) |
| tag = 'div'; -- poem replacement is in div tags so lang must use div tags | | tag = 'div'; -- poem replacement is in div tags so lang must use div tags |
| | elseif text:find ('<div') then -- reductive; if the text contains a div tag, we must use div tags |
| | tag = 'div'; |
| elseif mw.text.trim (text):find ('\n\n+') then -- contains implied p tags | | elseif mw.text.trim (text):find ('\n\n+') then -- contains implied p tags |
| text = mw.text.trim (text); -- trim leading and trailing whitespace characters | | text = mw.text.trim (text); -- trim leading and trailing whitespace characters |
Line 850: |
Line 903: |
| | | |
| if override_table[ietf] then -- look for whole IETF tag in override table | | if override_table[ietf] then -- look for whole IETF tag in override table |
| name = override_table[ietf][1]; | | name = override_table[ietf]; |
| elseif override_table[code] then -- not there so try basic language code | | elseif override_table[code] then -- not there so try basic language tag |
| name = override_table[code][1]; | | name = override_table[code]; |
| elseif lang_table[code] then -- shift to iana code/name table | | elseif lang_table[code] then -- shift to iana active tag/name table |
| name = lang_table[code][1]; -- table entries sometimes have multiple names, always take the first one | | name = lang_table[code]; |
| elseif lang_dep_table[code] then | | elseif lang_dep_table[code] then -- try the iana deprecated tag/name table |
| -- if cat then | | name = lang_dep_table[code]; |
| -- table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));
| |
| -- table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));
| |
| -- end
| |
| name = lang_dep_table[code][1]; -- table entries sometimes have multiple names, always take the first one | |
| end | | end |
|
| |
|
Line 893: |
Line 942: |
| local template = args.template or 'Lang'; | | local template = args.template or 'Lang'; |
|
| |
|
| | maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once |
| | maint_msgs = {}; |
| | |
| validate_cat_args (args); -- determine if categorization should be suppressed | | validate_cat_args (args); -- determine if categorization should be suppressed |
|
| |
|
Line 934: |
Line 986: |
| if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls | | if nil == args.italic then -- nil when |italic= absent or not set or |italic=default; args.italic controls |
| if ('latn' == subtags.script) or -- script is latn | | if ('latn' == subtags.script) or -- script is latn |
| (this_wiki_lang ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics) | | (this_wiki_lang_tag ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not this wiki's language, no script specified and not in poem markup but is wholly latn script (auto-italics) |
| args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic | | args.italic = 'italic'; -- DEFAULT for {{lang}} templates is upright; but if latn script set for font-style:italic |
| else | | else |
Line 993: |
Line 1,045: |
|
| |
|
| return _lang (args); | | return _lang (args); |
| | end |
| | |
| | |
| | --[[--------------------------< T R A N S L A T I O N _ M A K E >---------------------------------------------- |
| | |
| | stand-alone function to create literal translation of main text |
| | |
| | Also used by {{lang-x2}} |
| | |
| | ]] |
| | |
| | local function translation_make (args_t) |
| | local translation_t = {', '}; -- initialize output |
| | |
| | if 'none' ~= args_t.label then -- if we want a label |
| | table.insert (translation_t, '<small>'); -- open the <small> html tag |
| | if 'no' == args_t.link then |
| | table.insert (translation_t, '<abbr title="literal translation">lit.</abbr>'); -- unlinked form |
| | else |
| | table.insert (translation_t, make_wikilink ('Literal translation', 'lit.')); -- linked form |
| | end |
| | table.insert (translation_t, " </small>"); -- close the <small> html tag |
| | end |
| | table.insert (translation_t, table.concat ({''', args_t.translation, '''})); -- use html entities to avoid wiki markup confusion |
| | return table.concat (translation_t); -- make a big string and done |
| end | | end |
|
| |
|
Line 1,054: |
Line 1,131: |
| local template = args.template or 'Lang-xx'; | | local template = args.template or 'Lang-xx'; |
|
| |
|
| | maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once |
| | maint_msgs = {}; |
| | |
| if args[1] and args.text then | | if args[1] and args.text then |
| return make_error_msg ('conflicting: {{{1}}} and |text=', args, template); | | return make_error_msg ('conflicting: {{{1}}} and |text=', args, template); |
Line 1,141: |
Line 1,221: |
| table.insert (out, language_name); -- language name without wikilink | | table.insert (out, language_name); -- language name without wikilink |
| else | | else |
| if language_name:find ('languages') then | | if mw.ustring.find (language_name, 'languages', 1, true) then |
| table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink | | table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink |
| elseif lang_data.article_name[code] then | | elseif lang_data.article_name[code] then |
| table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data | | table.insert (out, make_wikilink (lang_data.article_name[code], language_name)); -- language name with wikilink from override data |
| else | | else |
| table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink | | table.insert (out, make_wikilink (language_name .. ' language', language_name)); -- language name with wikilink |
Line 1,165: |
Line 1,245: |
| table.insert (out, '<small>'); | | table.insert (out, '<small>'); |
| if script_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name | | if script_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name |
| translit_script_name = script_table[args['translit-script'][1]]; | | translit_script_name = script_table[args['translit-script']]; |
| else | | else |
| translit_script_name = language_name; -- fall back on language name | | translit_script_name = language_name; -- fall back on language name |
Line 1,187: |
Line 1,267: |
| | | |
| if is_set (args.translation) then -- translation (not supported in {{lang}}) | | if is_set (args.translation) then -- translation (not supported in {{lang}}) |
| table.insert (out, ', '); | | table.insert (out, translation_make (args)); |
| if 'none' ~= args.label then
| |
| table.insert (out, '<small>');
| |
| if 'no' == args.link then
| |
| table.insert (out, '<abbr title="literal translation">lit.</abbr>');
| |
| else
| |
| table.insert (out, make_wikilink ('Literal translation', 'lit.'));
| |
| end
| |
| table.insert (out, " </small>");
| |
| end
| |
| table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion
| |
| end | | end |
| | | |
Line 1,354: |
Line 1,424: |
| if msg then | | if msg then |
| local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) | | local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) |
| return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'}); | | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); |
| end | | end |
|
| |
|
Line 1,363: |
Line 1,433: |
|
| |
|
| if link then -- when |link=yes, wikilink the language name | | if link then -- when |link=yes, wikilink the language name |
| if language_name:find ('languages') then | | if mw.ustring.find (language_name, 'languages', 1, true) then |
| language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink | | language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink |
| elseif lang_data.article_name[code] then | | elseif lang_data.article_name[code] then |
| language_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data | | language_name = make_wikilink (lang_data.article_name[code], label or language_name); -- language name with wikilink from override data |
| else | | else |
| language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink | | language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink |
Line 1,418: |
Line 1,488: |
| template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) | | template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template) |
| end | | end |
| return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'}); | | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); |
| end | | end |
|
| |
|
Line 1,459: |
Line 1,529: |
| local msg; -- for when called functions return an error message | | local msg; -- for when called functions return an error message |
|
| |
|
| if is_set (args[3]) then -- [3] set when {{transl|code|standard|text}} | | maint_cats = {}; -- initialize because when this module required into another module, these only declared once so only initialzed once |
| | maint_msgs = {}; |
| | |
| | if is_set (args[3]) then -- [3] set when {{transliteration|code|standard|text}} |
| args.text = args[3]; -- get the transliterated text | | args.text = args[3]; -- get the transliterated text |
| args.translit_std = args[2] and args[2]:lower(); -- get the standard; lower case for table indexing | | args.translit_std = args[2] and args[2]:lower(); -- get the standard; lower case for table indexing |
|
| |
|
| if not title_table[args.translit_std] then | | if not title_table[args.translit_std] then |
| return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transl'); | | return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transliteration'); |
| end | | end |
| else | | else |
| if is_set (args[2]) then -- [2] set when {{transl|code|text}} | | if is_set (args[2]) then -- [2] set when {{transliteration|code|text}} |
| args.text = args[2]; -- get the transliterated text | | args.text = args[2]; -- get the transliterated text |
| else | | else |
| if args[1] and args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or its it the transliterated text? | | if args[1] and (args[1]:match ('^%a%a%a?%a?$') or -- args[2] missing; is args[1] a language or script tag or is it the transliterated text? |
| return make_error_msg ('no text', args, 'Transl'); -- args[1] is a code so we're missing text | | args[1]:match ('^%a%a%a?%-x%-')) then -- or is args[1] a private-use tag |
| | return make_error_msg ('no text', args, 'Transliteration'); -- args[1] is a code so we're missing text |
| else | | else |
| args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message | | args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message |
| return make_error_msg ('missing language / script code', args, 'Transl'); | | return make_error_msg ('missing language / script code', args, 'Transliteration'); |
| end | | end |
| end | | end |
Line 1,480: |
Line 1,554: |
|
| |
|
| if is_set (args[1]) then -- IANA language code used for html lang= attribute; or ISO 15924 script code | | if is_set (args[1]) then -- IANA language code used for html lang= attribute; or ISO 15924 script code |
| if args[1]:match ('^%a%a%a?%a?$') then -- args[1] has correct form? | | if args[1]:match ('^%a%a%a?%a?$') or args[1]:match ('^%a%a%a?%-x%-') then -- args[1] has correct form? |
| args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case | | args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters) or private-use; lower case because table indexes are lower case |
| else | | else |
| return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transl'); -- invalid language / script code | | return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transliteration'); -- invalid language / script code |
| end | | end |
| else | | else |
| return make_error_msg ('missing language / script code', args, 'Transl'); -- missing language / script code so quit | | return make_error_msg ('missing language / script code', args, 'Transliteration'); -- missing language / script code so quit |
| end | | end |
|
| |
|
| args.italic, msg = validate_italic (args); | | args.italic, msg = validate_italic (args); |
| if msg then | | if msg then |
| return make_error_msg (msg, args, 'Transl'); | | return make_error_msg (msg, args, 'Transliteration'); |
| end | | end |
| | | |
Line 1,499: |
Line 1,573: |
|
| |
|
| if override_table[args.code] then -- is code a language code defined in the override table? | | if override_table[args.code] then -- is code a language code defined in the override table? |
| language_name = override_table[args.code][1]; | | language_name = override_table[args.code]; |
| | args.code = args.code:match ('^%a%a%a?'); -- if private use, strip all but language subtag |
| elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables? | | elseif lang_table[args.code] then -- is code a language code defined in the standard language code tables? |
| language_name = lang_table[args.code][1]; | | language_name = lang_table[args.code]; |
| elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? | | elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? |
| language_name = lang_dep_table[args.code][1]; | | language_name = lang_dep_table[args.code]; |
| elseif script_table[args.code] then -- if here, code is not a language code; is it a script code? | | elseif script_table[args.code] then -- if here, code is not a language code; is it a script code? |
| language_name = script_table[args.code][1]; | | language_name = script_table[args.code]; |
| script = args.code; -- code was an ISO 15924 script so use that instead | | script = args.code; -- code was an ISO 15924 script so use that instead |
| args.code = ''; -- unset because not a language code | | args.code = ''; -- unset because not a language code |
| else | | else |
| return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transl'); -- invalid language / script code | | return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transliteration'); -- invalid language / script code |
| end | | end |
| -- here only when all parameters passed to make_translit() are valid | | -- here only when all parameters passed to make_translit() are valid |
Line 1,537: |
Line 1,612: |
| ]] | | ]] |
|
| |
|
| local function _category_from_tag (args) | | local function _category_from_tag (args_t) |
| local subtags = {}; -- IETF subtags script, region, variant, and private | | local subtags = {}; -- IETF subtags script, region, variant, and private |
| local raw_code = args[1]; -- save a copy of the input IETF subtag | | local raw_code = args_t[1]; -- save a copy of the input IETF subtag |
| local link = 'yes' == args['link']; -- make a boolean | | local link = 'yes' == args_t.link; -- make a boolean |
| local label = args.label; | | local label = args_t.label; |
| local code; -- the language code | | local code; -- the language code |
| local msg; -- gets an error message if IETF language tag is malformed or invalid | | local msg; -- gets an error message if IETF language tag is malformed or invalid |
Line 1,548: |
Line 1,623: |
| code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); | | code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code); |
| if msg then | | if msg then |
| local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template) | | local template = (args_t.template and table.concat ({'{{', args_t.template, '}}: '})) or ''; -- make template name (if provided by the template) |
| return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'}); | | return table.concat ({'<span style=\"color:#d33\">Error: ', template, msg, '</span>'}); |
| end | | end |
|
| |
|
Line 1,556: |
Line 1,631: |
| category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', ''); | | category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', ''); |
|
| |
|
| return category_name; | | if link then |
| | return table.concat ({'[[:', category_name, ']]'}); |
| | else |
| | return category_name; |
| | end |
| end | | end |
|
| |
|
Line 1,584: |
Line 1,663: |
| tag_from_name = tag_from_name, -- returns ietf tag associated with language name | | tag_from_name = tag_from_name, -- returns ietf tag associated with language name |
| name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates | | name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates |
| transl = transl, -- entry point for {{transl}} | | transl = transl, -- entry point for {{transliteration}} |
| | | |
| _category_from_tag = _category_from_tag, -- entry points when this module is require()d into other modules | | _category_from_tag = _category_from_tag, -- entry points when this module is require()d into other modules |
Line 1,595: |
Line 1,674: |
| _name_from_tag = _name_from_tag, | | _name_from_tag = _name_from_tag, |
| _transl = _transl, | | _transl = _transl, |
| | _translation_make = translation_make, |
| }; | | }; |