Module:ParseList: Difference between revisions

Jump to navigation Jump to search

Module:ParseList (view source)

Revision as of 19:06, 15 April 2024

4,324 bytes added ,  15 April
Improve output of htmlList style.
No edit summary
(Improve output of htmlList style.)
 
(26 intermediate revisions by 3 users not shown)
Line 2: Line 2:
local p = {}
local p = {}


-- Config options, may be overwritten in the main function
-- Config options, set in main function
local listDelimiters = ","
local listDelimiters
local makeElementsLinks = false
local makeElementsLinks
local pluralizeElements = false
local makeElementsPlural
local finalJoiningWord = "and"
local makeElementsSingular
local makeElementsLowercase
local useTemplateOnElements
local useTwoArgTemplateOnElements
local textDelim
local textLastDelim


function p.main(frame)
local function splitListString(listString)
local args = getArgs(frame, { frameOnly = true })
local strings = {}
return p._main(args)
for str in listString:gmatch("[^" .. listDelimiters .. "]+") do
end
table.insert(strings, str:match("^%s*(.-)%s*$"))
 
function p._main(args)
listDelimiters = args['delimiter'] or listDelimiters
makeElementsLinks = args['makeLinks'] or makeElementsLinks
pluralizeElements = args['pluralize'] or pluralizeElements
finalJoiningWord = args['joiningWord'] or finalJoiningWord
local type = args['type'] or 'sentence'
local converter = converters[type]
local elements = {}
for str in splitListString(args[1]) do
table.insert(elements, processElement(str))
end
end
return converter(elements)
return strings
end
 
local function splitListString(listString)
    local strings = {}
    for str in listString:gmatch("[^" .. listDelimiters .. "]+") do
        table.insert(strings, str:match("^%s*(.-)%s*$"))
    end
    return strings
end
end


-- This is a TWO-WAY conversion table of singular words and their corresponding
-- plural form, for those that wouldn't be handled correctly by the automatic
-- rules implemented further down below.  Note that we don't need to cover most
-- regular English words, as they're unlikely to ever be used with this module.
-- The kind of stuff you want to add here is gameplay elements like classes,
-- weapons, races, and so on.
local specialPlurals = {
local specialPlurals = {
Thief = "Thieves",
-- Weapons
thief = "thieves",
Glaive = "Glaives",
Quarterstaff = "Quarterstaves",
glaive = "glaives",
quarterstaff = "quarterstaves",
Staff = "Staves",
staff = "staves",
-- Races
Gith = "Gith",
gith = "gith",
Githyanki = "Githyanki",
githyanki = "githyanki",
Duergar = "Duergar",
duergar = "duergar",
Drow = "Drow",
drow = "drow",
Dragonborn = "Dragonborn",
dragonborn = "dragonborn",
-- Creature types
Fey = "Fey",
fey = "fey",
Undead = "Undead",
undead = "undead",
}
}


local function processElement(str)
-- Checks if str is equal to or ends in one of the keys in specialPlurals.
if pluralizeElements then
-- Returns the pluralized version if so, otherwise nil.
local plural = specialPlurals[str] or str .. "s"
local function findSpecialPlural(str)
if makeElementsLinks then
for singular, plural in pairs(specialPlurals) do
return "[[" .. str .. "|" .. plural .. "]]"
if str == singular then
else
return plural
return plural
end
end
else
local len = #singular
if makeElementsLinks then
local suffix = str:sub(-len, -1)
return "[[" .. str .. "]]"
if (suffix == singular) then
else
return str:sub(1, -len - 1) .. plural
return str
end
end
end
 
-- Checks if str is equal to or ends in one of the values in specialPlurals.
-- Returns the singular version if so, otherwise nil.
local function findSpecialSingular(str)
for singular, plural in pairs(specialPlurals) do
if str == plural then
return singular
end
local len = #plural
local suffix = str:sub(-len, -1)
if suffix == plural then
return str:sub(1, -len - 1) .. singular
end
end
end
end
end
end


-- Checks for a special pluralization first, then implements these rules:
-- ...f -> ...ves
-- ...y -> ...ies
-- ...s -> ...ses
-- ...ch -> ...ches
-- ...sh -> ...shes
-- ... -> ...s
local function makePlural(str)
local sp = findSpecialPlural(str)
if sp then
return sp
end
local last1 = str:sub(-1)
if last1 == "f" then
return str:sub(1, -2) .. "ves"
elseif last1 == "y" then
return str:sub(1, -2) .. "ies"
elseif last1 == "s" then
return str .. "es"
end
local last2 = str:sub(-2)
if last2 == "ch" or last2 == "sh" then
return str .. "es"
end
return str .. "s"
end
-- Checks for a special singularization first, then implements these rules:
-- ...ves -> ...f
-- ...ies -> ...y
-- ...ses -> ...s
-- ...ches -> ...ch
-- ...shes -> ...sh
-- ...s -> ...
-- ... -> ...
local function makeSingular(str)
local special = findSpecialSingular(str)
if special then
return special
end
local last3 = str:sub(-3)
if last3 == "ves" then
return str:sub(1, -4) .. "f"
elseif last3 == "ies" then
return str:sub(1, -4) .. "y"
elseif last3 == "ses" then
return str:sub(1, -3)
end
local last4 = str:sub(-4)
if last4 == "ches" or last4 == "shes" then
return str:sub(1, -3)
end
if str:sub(-1) == "s" then
return str:sub(1, -2)
end
return str
end
-- Applies the various per-element transforms.  Frame is needed for template
-- expansion; it may be nil if template transforms won't be applied.
local function processElement(str, frame)
local original = str
if makeElementsPlural then
str = makePlural(str)
elseif makeElementsSingular then
str = makeSingular(str)
end
if makeElementsLowercase then
str = str:lower()
end
if makeElementsLinks then
return "[[" .. original .. "|" .. str .. "]]"
elseif useTemplateOnElements then
return frame:expandTemplate{
title = useTemplateOnElements,
args = { str }
}
elseif useTwoArgTemplateOnElements then
return frame:expandTemplate{
title = useTwoArgTemplateOnElements,
args = { original, str }
}
end
return str
end
-- These functions implement different output styles.  The elements will have
-- already gone through processElement() at this point, so they only need to be
-- glued together to produce the desired style of listing format.
local converters = {
local converters = {
sentence = function (elements)
text = function (elements)
    local count = #elements
local result = ""
    if count == 0 then
local count = #elements
    return ""
    elseif count == 1 then
    return elements[1]
    elseif count == 2 then
return elements[1] .. " " .. finalJoiningWord .. " " .. elements[2]
    end
    local result = ""
for i, str in ipairs(elements) do
for i, str in ipairs(elements) do
if i < count then
if i == 1 then
result = result .. str .. ", "
result = str
elseif i < count then
result = result .. textDelim .. str
else
else
result = result .. finalJoiningWord .. " " .. str
result = result .. textLastDelim .. str
end
end
    end
end
    return result
return result
end,
end,
htmlList = function (elements)
htmlList = function (elements)
local result = ""
local result = "<ul>\n"
for str in elements do
for i, str in ipairs(elements) do
result = result .. "* " .. str
result = result .. "<li>" .. str .. "</li>\n"
end
return result .. "</ul>"
end,
tableList = function (elements)
local result = "<div class=\"bg3wiki-tablelist\">"
for i, str in ipairs(elements) do
result = result .. str .. "\n"
end
return result .. "</div>"
end,
htmlListNoBullets = function (elements)
local result = "<ul style='list-style: none; margin: 0;'>\n"
for i, str in ipairs(elements) do
result = result .. "<li>" .. str .. "</li>\n"
end
end
return result .. "</ul>"
end,
end,
simpleList = function (elements)
simpleList = function (elements)
local result = ""
local result = ""
local first = true
local first = true
for str in elements do
for i, str in ipairs(elements) do
if first then
if first then
result = str
result = str
Line 100: Line 220:
end,
end,
}
}
function p.main(frame)
local args = getArgs(frame, { frameOnly = true })
return p._main(args, frame)
end
-- Frame is needed for template expansion; may be nil if the useTemplate and
-- useTemplate2 args are nil.
function p._main(args, frame)
listDelimiters = args['delimiter'] or ","
makeElementsLinks = args['makeLinks']
makeElementsPlural = args['makePlural']
makeElementsSingular = args['makeSingular']
makeElementsLowercase = args['makeLowercase']
useTemplateOnElements = args['useTemplate']
useTwoArgTemplateOnElements = args['useTemplate2']
textDelim = args['textDelim']
if textDelim then
textLastDelim = args['textLastDelim'] or textDelim
else
textDelim = ', '
textLastDelim = args['textLastDelim'] or ', and '
end
local style = args['style'] or args['type'] or 'text'
local converter = converters[style]
local elements = {}
local listString = args[1]
local strings = splitListString(listString)
for i, str in ipairs(strings) do
table.insert(elements, processElement(str, frame))
end
return converter(elements)
end


return p
return p
Retrieved from "https://bg3.wiki/wiki/Special:MobileDiff/20570...173551"

Navigation menu