The Petit Planet Wiki

Module:Data to Table: Difference between revisions

Browse history interactively
← Older edit

ReisuDesign (talk | contribs)

3 user groups
4,145 edits
undo
ReisuDesign (talk | contribs)
confirmed, Interface administrators, moderator
4,145 edits
No edit summary
ReisuDesign (talk | contribs)
confirmed, Interface administrators, moderator
4,145 edits
No edit summary
 
(4 intermediate revisions by the same user not shown)
Line 14: Line 14:




-- Escape characters
-- Escape characters for Lua strings
local function clean(txt)
local function clean(txt)
return txt
return txt
:gsub('\\', '\\\\')
:gsub('\\', '\\\\')
:gsub('\'', '\\\'')
:gsub('\'', '\\\'')
end
-- Parse DPL data
local function parseInfo(info, frame)
if not info then
return {}
end
if ne(frame.args.cleanTT) then
info = CleanTT(info)
end
return lib.parseTemplateFormat(
info,
';;',
'$$$',
'=='
)
end
-- Get grouped JSON data
local function getJsonGroups(frame)
local groups = {}
local i = 1
while true do
local groupName = frame.args['group' .. i]
local groupInfo = frame.args['group' .. i .. '_info']
-- Stop when neither argument exists.
if groupName == nil and groupInfo == nil then
break
end
if ne(groupName) and groupInfo ~= nil then
local info = parseInfo(groupInfo, frame)
local entries = {}
-- Collect entries
for _, entry in lib.spairs(
info,
function(tVal, a, b)
local aPage = tostring(tVal[a].page or a)
local bPage = tostring(tVal[b].page or b)
return aPage < bPage
end
) do
if ne(entry.page) then
entries[#entries + 1] = entry.page
end
end
-- Only add the group if it actually contains entries.
if #entries > 0 then
groups[groupName] = entries
end
end
i = i + 1
end
return groups
end
-- Format grouped data as readable JSON
function p.FormatJSONGroups(groups)
local result = {}
table.insert(result, '{')
-- Get group names
local groupNames = {}
for name in pairs(groups) do
groupNames[#groupNames + 1] = name
end
table.sort(groupNames)
-- Build each group
for i, name in ipairs(groupNames) do
local entries = groups[name]
local groupComma = (i < #groupNames) and ',' or ''
table.insert(
result,
'\t' ..
mw.text.jsonEncode(name) ..
': ['
)
for j, entry in ipairs(entries) do
local entryComma = (j < #entries) and ',' or ''
table.insert(
result,
'\t\t' ..
mw.text.jsonEncode(entry) ..
entryComma
)
end
table.insert(
result,
'\t]' .. groupComma
)
end
table.insert(result, '}')
return table.concat(result, '\n')
end
end


Line 26: Line 148:
local dataKeys = {}
local dataKeys = {}
local rawKeys = {}
local rawKeys = {}
-- ============================================================
-- JSON MODE
-- ============================================================
if tostring(frame.args.json) == '1' then
-- --------------------------------------------------------
-- Grouped JSON mode
-- --------------------------------------------------------
local groups = getJsonGroups(frame)
-- If groups were supplied, output the complete JSON object.
if next(groups) ~= nil then
local jsonText = p.FormatJSONGroups(groups)
return frame:extensionTag(
'syntaxhighlight',
jsonText,
{
lang = 'json',
copy = ''
}
)
end
-- --------------------------------------------------------
-- Simple JSON array mode
-- --------------------------------------------------------
if frame.args.info then
info = parseInfo(frame.args.info, frame)
local jsonEntries = {}
for _, entry in lib.spairs(
info,
function(tVal, a, b)
local aPage = tostring(tVal[a].page or a)
local bPage = tostring(tVal[b].page or b)
return aPage < bPage
end
) do
if ne(entry.page) then
jsonEntries[#jsonEntries + 1] = entry.page
end
end
local jsonText = mw.text.jsonEncode(jsonEntries)
return frame:extensionTag(
'syntaxhighlight',
jsonText,
{
lang = 'json',
copy = ''
}
)
end
return ''
end
-- ============================================================
-- NORMAL LUA MODE
-- ============================================================


-- Parse DPL data
-- Parse DPL data
if frame.args.info then
if frame.args.info then
if ne(frame.args.cleanTT) then
frame.args.info = CleanTT(frame.args.info)
end


info = lib.parseTemplateFormat(
info = parseInfo(frame.args.info, frame)
frame.args.info,
 
';;',
'$$$',
'=='
)
else
else
return ''
return ''
end
end


-- Parse keys
-- Parse keys
Line 47: Line 237:
dataKeys = p.ParseKeys(frame.args.keys)
dataKeys = p.ParseKeys(frame.args.keys)
end
end


-- Parse unquoted/raw keys
-- Parse unquoted/raw keys
Line 52: Line 243:
rawKeys = p.ParseKeys(frame.args.unquoted)
rawKeys = p.ParseKeys(frame.args.unquoted)
end
end


-- Block formatting
-- Block formatting
Line 57: Line 249:
block = true
block = true
end
end


local sortkey = frame.args.sortkey or 'page'
local sortkey = frame.args.sortkey or 'page'
local subtable = frame.args.subtable
local subtable = frame.args.subtable
-- Constant value mode
-- If |value=day is supplied, every page gets that value.
local constantValue = frame.args.value
local valueUnquoted = false
if constantValue ~= nil then
for _, rawKey in ipairs(rawKeys) do
if rawKey == 'value' then
valueUnquoted = true
break
end
end
end




-- Check whether a key should be output as raw Lua
-- Check whether a key should be output as raw Lua
local function isUnquotedKey(key)
local function isUnquotedKey(key)
for _, rawKey in ipairs(rawKeys) do
for _, rawKey in ipairs(rawKeys) do
if rawKey == key then
if rawKey == key then
return true
return true
end
end
end
end


Line 82: Line 297:
info,
info,
function(tVal, a, b)
function(tVal, a, b)
if sortkey == 'INPUT' then
if sortkey == 'INPUT' then
return a < b
return a < b
else
else
return (tVal[a][sortkey] or '') < (tVal[b][sortkey] or '')
return (tVal[a][sortkey] or '') <
(tVal[b][sortkey] or '')
end
end
end
end
) do
) do


if ne(entry.page) then
if ne(entry.page) then
entry.page = clean(entry.page)
entry.page = clean(entry.page)


-- No data keys: output page as a simple string
if #dataKeys == 0 then


-- Single-value mode: ['Page'] = 'value'
-- ----------------------------------------------------
if ne(frame.args.singlevalue) then
-- Constant value mode
-- ----------------------------------------------------


local value = entry[frame.args.singlevalue] or ''
if constantValue ~= nil and #dataKeys == 0 then


result:wikitext(
local value
'\t[\'',
entry.page,
'\'] = \'',
clean(value),
'\',\n'
)


if valueUnquoted then
value = clean(constantValue)
else
else
value = '\'' ..
clean(constantValue) ..
'\''
end
result:wikitext(
'\t[\'',
entry.page,
'\'] = ',
value,
',\n'
)
-- ----------------------------------------------------
-- No data keys
-- ----------------------------------------------------
elseif #dataKeys == 0 then
result:wikitext(
'\t\'',
entry.page,
'\',\n'
)


result:wikitext(
'\t\'',
entry.page,
'\',\n'
)


end
-- ----------------------------------------------------
-- Normal nested table mode
-- ----------------------------------------------------


else
else
Line 127: Line 363:
local valid = false
local valid = false
local values = mw.html.create()
local values = mw.html.create()


-- Entry name
-- Entry name
Line 134: Line 371:
'\'] = {'
'\'] = {'
)
)


-- Build entry
-- Build entry
local function parseLevels(K, level)
local function parseLevels(K, level)
level = level or 1
level = level or 1


Line 154: Line 393:
)
)
)
)


elseif type(K) == 'table' then
elseif type(K) == 'table' then
Line 168: Line 408:
'},'
'},'
)
)
end
end
end
end


parseLevels(dataKeys, 1)
parseLevels(dataKeys, 1)


-- Return table if there is valid data
-- Return table if there is valid data
if valid then
if valid then
values:wikitext('\n')
values:wikitext('\n')
result:node(values)
result:node(values)
else
else
result:wikitext(
result:wikitext(
'\t\'',
'\t\'',
Line 183: Line 429:
'\',\n'
'\',\n'
)
)
end
end
end
end
end
end
end
end


result:wikitext('}')
result:wikitext('}')




-- Wrap output in syntaxhighlight
-- ============================================================
-- LUA SYNTAX HIGHLIGHT
-- ============================================================
 
local luaText = tostring(result)
local luaText = tostring(result)
 
-- Decode HTML entities introduced by mw.html
-- Decode HTML entities introduced by mw.html
luaText = mw.text.decode(luaText)
luaText = mw.text.decode(luaText)
 
 
local output = frame:extensionTag(
local output = frame:extensionTag(
'syntaxhighlight',
'syntaxhighlight',
Line 204: Line 456:
copy = ''
copy = ''
}
}
)
)




-- Copy button
-- ============================================================
-- COPY BUTTON
-- ============================================================
 
-- Keep Module:CopyText for normal Lua output.
if frame.args.copy then
if frame.args.copy then
output = require('Module:CopyText')._main({
output = require('Module:CopyText')._main({
output,
output,
Line 214: Line 471:
'Copy Table'
'Copy Table'
})
})
end
end


return output
return output
Line 220: Line 479:




-- Format data
-- ================================================================
-- FORMAT DATA
-- ================================================================
 
function p.BuildEntry(value, key, level, subtable, unquoted)
function p.BuildEntry(value, key, level, subtable, unquoted)
level = level or 1
level = level or 1


local container = mw.html.create()
local container = mw.html.create()


-- Default missing values
-- Default missing values
Line 230: Line 494:


if key == 'number' then
if key == 'number' then
value = '0'
value = '0'
unquoted = true
unquoted = true
else
else
value = ''
value = ''
unquoted = false
unquoted = false
end
end
end
end
Line 250: Line 518:
table.concat(value, '\', \'') ..
table.concat(value, '\', \'') ..
' }'
' }'


elseif unquoted and value ~= '' then
elseif unquoted and value ~= '' then
Line 255: Line 524:
-- Raw Lua value
-- Raw Lua value
value = clean(value)
value = clean(value)


else
else
Line 284: Line 554:


first[level] = false
first[level] = false


if level > 2 then
if level > 2 then
first[2] = false
first[2] = false
end
end


if level > 1 then
if level > 1 then
Line 309: Line 581:


end
end


return container
return container
Line 314: Line 587:




-- Parse data keys into specified levels
-- ================================================================
-- PARSE DATA KEYS INTO SPECIFIED LEVELS
-- ================================================================
 
function p.ParseKeys(keys)
function p.ParseKeys(keys)
keys = lib.split(keys, ';;')
keys = lib.split(keys, ';;')


Retrieved from "https://petitplanet.wiki/Module:Data_to_Table"