Module:Lang: Difference between revisions

local unicode = require ("Module:Unicode data"); -- for is_latin() and is_rtl()

local yesno = require ('Module:Yesno');

local function in_array ( needle, haystack )

local code, script, region, variant, private; -- ietf tag parts

local pattern = { -- table of tables holding acceptibe ietf tag patterns and short names of the ietf part captured by the pattern

{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%d%d%d%d)$', 's', 'r', 'v'}, -- 1 - ll-Ssss-RR-variant (where variant is 4 digits)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%d%d%d%d)$', 's', 'r', 'v'}, -- 2 - ll-Ssss-DDD-variant (where region is 3 digits; variant is 4 digits)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'r', 'v'}, -- 3 - ll-Ssss-RR-variant (where variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'r', 'v'}, -- 4 - ll-Ssss-DDD-variant (where region is 3 digits; variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d%d)$', 's', 'v'}, -- 5 - ll-Ssss-variant (where variant is 4 digits)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 's', 'v'}, -- 6 - ll-Ssss-variant (where variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%a%a)%-(%d%d%d%d)$', 'r', 'v'}, -- 7 - ll-RR-variant (where variant is 4 digits)

{'^(%a%a%a?)%-(%d%d%d)%-(%d%d%d%d)$', 'r', 'v'}, -- 8 - ll-DDD-variant (where region is 3 digits; variant is 4 digits)

{'^(%a%a%a?)%-(%a%a)%-(%w%w%w%w%w%w?%w?%w?)$', 'r', 'v'}, -- 9 - ll-RR-variant (where variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%d%d%d)%-(%w%w%w%w%w%w?%w?%w?)$', 'r', 'v'}, -- 10 - ll-DDD-variant (where region is 3 digits; variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%d%d%d%d)$', 'v'}, -- 11 - ll-variant (where variant is 4 digits)

{'^(%a%a%a?)%-(%w%w%w%w%w%w?%w?%w?)$', 'v'}, -- 12 - ll-variant (where variant is 5-8 alnum characters)

{'^(%a%a%a?)%-(%a%a%a%a)%-(%a%a)$', 's', 'r'}, -- 13 - ll-Ssss-RR

{'^(%a%a%a?)%-(%a%a%a%a)%-(%d%d%d)$', 's', 'r'}, -- 14 - ll-Ssss-DDD (region is 3 digits)

{'^(%a%a%a?)%-(%a%a%a%a)$', 's'}, -- 15 - ll-Ssss

{'^(%a%a%a?)%-(%a%a)$', 'r'}, -- 16 - ll-RR

{'^(%a%a%a?)%-(%d%d%d)$', 'r'}, -- 17 - ll-DDD (region is 3 digits)

{'^(%a%a%a?)$'}, -- 18 - ll

{'^(%a%a%a?)%-x%-(%w%w?%w?%w?%w?%w?%w?%w?)$', 'p'}, -- 19 - ll-x-pppppppp (private is 1-8 alnum characters)

}

local t = {}; -- table of captures; serves as a translator between captured ietf tag parts and named variables

for i, v in ipairs (pattern) do -- spin through the pattern table looking for a match

local c1, c2, c3, c4; -- captures in the 'pattern' from the pattern table go here

c1, c2, c3, c4 = source:match (pattern[i][1]); -- one or more captures set if source matches pattern[i])

if c1 then -- c1 always set on match

code = c1; -- first capture is always code

t = {

[pattern[i][2] or 'x'] = c2, -- fill the table of captures with the rest of the captures

[pattern[i][3] or 'x'] = c3, -- take index names from pattern table and assign sequential captures

[pattern[i][4] or 'x'] = c4, -- index name may be nil in pattern[i] table so "or 'x'" spoofs a name for this index in this table

};

script = t.s or ''; -- translate table contents to named variables;

region = t.r or ''; -- absent table entries are nil so set named ietf parts to empty string for concatenation

variant= t.v or '';

private = t.p or '';

break; -- and done

end

end

if not code then

--[[--------------------------< D I V _ M A R K U P _ A D D >--------------------------------------------------

adds <i> and </i> tags to list-item text or to implied <p>..</p> text. mixed not supported

]]

local function div_markup_add (text, style)

local implied_p = {};

if text:find ('^\n[%*:;#]') then -- look for list markup; list markup must begin at start of text

if 'italic' == style then

return mw.ustring.gsub (text, '(\n[%*:;#]+)([^\n]+)', '%1<i>%2</i>'); -- insert italic markup at each list item

else

return text;

end

end

if text:find ('\n+') then -- look for any number of \n characters in text

text = text:gsub ('([^\n])\n([^\n])', '%1 %2'); -- replace single newline characters with a space character which mimics mediawiki

if 'italic' == style then

text = text:gsub('[^\n]+', '<p><i>%1</i></p>'); -- insert p and italic markup tags at each impled p (two or more consecutive '\n\n' sequences)

else

text = text:gsub ('[^\n]+', '<p>%1</p>'); -- insert p markup at each impled p

text = text:gsub ('\n', ''); -- strip newline characters

end

end

return text;

end

--[[--------------------------< M A K E _ T E X T _ H T M L >--------------------------------------------------

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

local function make_text_html (code, text, tag, rtl, style, size, language)

local html = {};

table.insert (html, '&#42;'); -- move proto language text prefix outside of italic markup if any; use numeric entity because plane splat confuses MediaWiki

if 'span' == tag then -- default html tag for inline content

if 'italic' == style then -- but if italic

tag = 'i'; -- change to <i> tags

end

else -- must be div so go

text = div_markup_add (text, style); -- handle implied <p>, implied <p> with <i>, and list markup (*;:#) with <i>

table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag

table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute

if rtl or unicode.is_rtl(text) then

table.insert (html, ' dir="rtl"'); -- add direction attribute for right to left languages

table.insert (html, ' style=\"font-style:normal;'); -- override external markup, if any

table.insert (html, table.concat ({' font-size:', size, ';'})); -- add when style attribute already inserted

table.insert (html, table.concat ({' style=\"font-size:', size, ';'})); -- create style attribute

table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text

table.insert (html, ' collective text\"'); -- for collective languages

table.insert (html, ' language text\"'); -- for individual languages

table.insert (html, '>'); -- close the opening html tag

table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag

table.insert (html, text); -- insert the text

table.insert (html, table.concat ({'</', tag, '>'})); -- close the <i>, <span>, or <div> html tag

if rtl then -- legacy; shouldn't be necessary because all of the rtl text is wrapped inside an html tag with dir="rtl" attribute

table.insert (html, '&lrm;'); -- make sure the browser knows that we're at the end of the rtl

return table.concat (html); -- put it all together and done

--[[--------------------------< V A L I D A T E _ T E X T >----------------------------------------------------

either as ''itself'' or as '''''bold italic''''' unless |italic=unset or |italic=invert.

]]

for proto languages, text is prefixed with a splat. We do that here as a flag for make_text_html() so that a splat

end

--[[--------------------------< H A S _ P O E M _ T A G >------------------------------------------------------

looks for a poem strip marker in text; returns true when found; false else

auto-italic detection disabled when text has poem stripmarker because it is not possible for this code to know

the content that will replace the stripmarker.

]]

local function has_poem_tag (text)

return text:find ('\127[^\127]*UNIQ%-%-poem%-[%a%d]+%-QINU[^\127]*\127') and true or false;

end

--[[--------------------------< H T M L _ T A G _ S E L E C T >------------------------------------------------

Inspects content of and selectively trims text. Returns text and the name of an appropriate html tag for text.

If text contains:

\n\n text has implied <p>..</p> tags - trim leading and trailing whitespace and return

If text begins with list markup:

\n* unordered

\n; definition

\n: definition

\n# ordered

trim all leading whitespace except \n and trim all trailing whitespace

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.

]]

local function html_tag_select (text)

local tag;

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

elseif mw.text.trim (text):find ('\n\n+') then -- contains implied p tags

text = mw.text.trim (text); -- trim leading and trailing whitespace characters

tag = 'div'; -- must be div because span may not contain p tags (added later by MediaWiki); poem replacement is in div tags

elseif text:find ('\n[%*:;%#]') then -- if text has list markup

text = text:gsub ('^[\t\r\f ]*', ''):gsub ('%s*$', ''); -- trim all whitespace except leading newline character '\n'

tag = 'div'; -- must be div because span may not contain ul, dd, dl, ol tags (added later by MediaWiki)

else

text = mw.text.trim (text); -- plain text

tag = 'span'; -- so span is fine

end

return text, tag;

local function lang (frame)

local args = getArgs (frame, { -- this code so that we can detect and handle wiki list markup in text

valueFunc = function (key, value)

if 2 == key or 'text' == key then -- the 'text' parameter; do not trim wite space

return value; -- return untrimmed 'text'

elseif value then -- all other values: if the value is not nil

value = mw.text.trim (value); -- trim whitespace

if '' ~= value then -- empty string when value was only whitespace

return value;

end

end

return nil; -- value was empty or contained only whitespace

end -- end of valueFunc

});

local tag = 'span'; -- initial value for make_text_html()

msg = validate_text ('lang', args); -- ensure that |text= is set

args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly

if ('latn' == subtags.script) or -- script is latn

('en' ~= code and not is_set (subtags.script) and not has_poem_tag (args.text) and unicode.is_Latin (args.text)) then -- text not English, 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

subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag

if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization

language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name

elseif lang_data.override[code] then

language_name = lang_data.override[code][1] -- then language names taken from the override table

if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, language_name));

table.insert (out, render_maint(args.nocat)); -- maintenance messages and categories

For each {{lang-xx}} template choose the appropriate entry-point function so that this function knows the default

|script = IANA script code; especially for use with languages that use multiple writing systems

|link = boolean false ('no') does not link code-spcified language name to associated language article

|cat = boolian false ('no') opposite form of |nocat=

|label = 'none' to suppress all labeling (language name, 'translit.', 'lit.')

for those {{lang-xx}} templates that support transliteration (those templates where |text= is not entirely latn script):

local args = getArgs(frame,

{

parentFirst= true, -- parameters in the template override parameters set in the {{#invoke:}}

valueFunc = function (key, value)

if 1 == key then -- the 'text' parameter; do not trim wite space

return value; -- return untrimmed 'text'

elseif value then -- all other values: if the value is not nil

value = mw.text.trim (value); -- trim whitespace

if '' ~= value then -- empty string when value was only whitespace

return value;

end

end

return nil; -- value was empty or contained only whitespace

end -- end of valueFunc

});

local tag = 'span'; -- initial value for make_text_html()

args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly

subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag

if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization

language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name

table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size))

if is_set (args.translit) and not unicode.is_Latin (args.text) then -- transliteration (not supported in {{lang}}); not supported when args.text is wholly latn text (this is an imperfect test)

local function lang_xx_italic (frame)

local function lang_xx_inherit (frame)

local function name_from_code (frame)

local function transl (frame)

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

]]

return {

lang = lang, -- entry point for {{lang}}

lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}}

lang_xx_italic = lang_xx_italic,

name_from_code = name_from_code, -- used for template documentation; possible use in ISO 639 name from code templates

transl = transl, -- entry point for {{transl}}

};