ICANNWiki

Module:TemplateStarter: Difference between revisions

← Older edit
MarkWD (talk | contribs)
Bureaucrats, Check users, Interface administrators, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Editors (Semantic MediaWiki), steward, Suppressors, Administrators, Temporary account IP viewers
25,069 edits
// via Wikitext Extension for VSCode
Maintenance update // via Wikitext Extension for VSCode
 
(8 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:TemplateStarter
--[[
-- Generates configurable template structures for new pages using ConfigRepository
* Name: TemplateStarter
* Author: Mark W. Datysgeld
* Description: Generates configurable template structures for new pages using ConfigRepository with support for variants and placeholder replacement
* Notes: Template generation from ConfigRepository configs; support for campaign variants; placeholder replacement in boilerplate text; creator field management; caching of template lists; includes error handling and validation
]]


local p = {}
local p = {}
Line 148: Line 152:
      
      
     templateType = mw.text.trim(tostring(templateType))
     templateType = mw.text.trim(tostring(templateType))
   
    -- Handle "None" special case
    if templateType == "None" then
        return ""
    end
      
      
     -- Parse template to check if it's a variant
     -- Parse template to check if it's a variant
Line 170: Line 179:
     end
     end
      
      
    -- No complex error handling here
     local templates = {}
     local templates = {}
      
      
    -- Check if ConfigRepository.templates exists
     if ConfigRepository.templates then
     if ConfigRepository.templates then
         local index = 1
         local index = 1
         for templateName, _ in pairs(ConfigRepository.templates) do
         for templateName, config in pairs(ConfigRepository.templates) do
             if templateName and templateName ~= "" then
            -- Include template if page_creator is not explicitly false
             if templateName and templateName ~= "" and (not config.meta or config.meta.page_creator ~= false) then
                 templates[index] = templateName
                 templates[index] = templateName
                 index = index + 1
                 index = index + 1
Line 184: Line 192:
         table.sort(templates)
         table.sort(templates)
     end
     end
     -- No fallback! If ConfigRepository fails, return empty list (single source of truth)
      
 
    -- Update cache
     templateListCache = templates
     templateListCache = templates
     templateListCacheTime = currentTime
     templateListCacheTime = currentTime
Line 193: Line 199:
end
end


-- Get list of available templates including variants
-- Get list of available templates including campaign combinations
function p.getAvailableTemplatesWithVariants()
function p.getAvailableTemplatesWithVariants()
     local templates = p.getAvailableTemplates()
    -- Get the filtered list of base templates that are allowed for page creation
     local templatesWithVariants = {}
     local baseTemplates = p.getAvailableTemplates()
     local index = 1
     local templatesWithCampaigns = {}
   
    -- Use a map to ensure uniqueness before adding to the final list
     local templateMap = {}
      
      
     -- Add base templates first
     -- Add base templates to the map
     for _, templateName in ipairs(templates) do
     for _, templateName in ipairs(baseTemplates) do
         templatesWithVariants[index] = templateName
         templateMap[templateName] = true
        index = index + 1
     end
     end
      
      
     -- Add variants
     -- Iterate through campaigns to find applicable templates
     if ConfigRepository.templates then
     if ConfigRepository.campaigns then
         for templateName, config in pairs(ConfigRepository.templates) do
         for campaignId, campaign in pairs(ConfigRepository.campaigns) do
             if config.variants then
             if campaign.applicable_templates then
                 for variantKey, variant in pairs(config.variants) do
                 for _, templateName in ipairs(campaign.applicable_templates) do
                     -- Only include active variants
                     -- Only include if the base template is allowed for page creation
                     if variant.state and variant.name then
                     if templateMap[templateName] then
                         templatesWithVariants[index] = variant.name
                         local campaignTemplateName = templateName .. " (" .. campaign.name .. ")"
                         index = index + 1
                         templateMap[campaignTemplateName] = true
                     end
                     end
                 end
                 end
Line 220: Line 228:
     end
     end
      
      
     -- Sort the combined list
    -- Convert map keys to a list
     table.sort(templatesWithVariants)
    local index = 1
    for templateName, _ in pairs(templateMap) do
        templatesWithCampaigns[index] = templateName
        index = index + 1
    end
   
     -- Sort the final combined list
     table.sort(templatesWithCampaigns)
   
    -- Add "None" option at the beginning
    table.insert(templatesWithCampaigns, 1, "None")
      
      
     return templatesWithVariants
     return templatesWithCampaigns
end
end


-- Parse variant template name to get base template and variant info
-- Parse campaign template name to get base template and campaign info
function p.parseVariantTemplate(templateName)
function p.parseVariantTemplate(templateName)
     if not templateName or templateName == "" then
     if not templateName or templateName == "" or templateName == "None" then
         return nil
         return nil
     end
     end
      
      
     -- Check if this is a variant by looking for the pattern in all templates
     -- Check if this is a campaign combination by looking for the pattern "Template (Campaign Name)"
     if ConfigRepository.templates then
     if ConfigRepository.campaigns then
         for baseTemplateName, config in pairs(ConfigRepository.templates) do
         for campaignId, campaign in pairs(ConfigRepository.campaigns) do
             if config.variants then
             local expectedName = " (" .. campaign.name .. ")"
                for variantKey, variant in pairs(config.variants) do
            if templateName:sub(-#expectedName) == expectedName then
                    if variant.state and variant.name == templateName then
                local baseTemplateName = templateName:sub(1, -#expectedName - 1)
                        return {
                -- Verify this is a valid combination
                            baseTemplate = baseTemplateName,
                if campaign.applicable_templates then
                            variantKey = variantKey,
                    for _, applicableTemplate in ipairs(campaign.applicable_templates) do
                            variant = variant
                        if applicableTemplate == baseTemplateName then
                         }
                            return {
                                baseTemplate = baseTemplateName,
                                variantKey = campaignId,
                                variant = {
                                    name = templateName,
                                    campaign_template = campaign.json_config
                                }
                            }
                         end
                     end
                     end
                 end
                 end
Line 249: Line 275:
     end
     end
      
      
     -- Not a variant, return as base template
     -- Not a campaign combination, return as base template
     return {
     return {
         baseTemplate = templateName,
         baseTemplate = templateName,
Line 307: Line 333:
-- Get creator fields for a specific template type
-- Get creator fields for a specific template type
function p.getCreatorFields(templateType)
function p.getCreatorFields(templateType)
     if not templateType or templateType == "" then
     if not templateType or templateType == "" or templateType == "None" then
         return {}
         return {}
     end
     end
      
      
     local config = ConfigRepository.getConfig(templateType)
    -- Parse template to resolve variants to base template
    local parsedTemplate = p.parseVariantTemplate(templateType)
    local baseTemplateName = parsedTemplate and parsedTemplate.baseTemplate or templateType
   
     local config = ConfigRepository.getConfig(baseTemplateName)
     return config.creatorFields or {}
     return config.creatorFields or {}
end
end
Line 346: Line 376:
         end
         end
     end
     end
   
    return result
end
-- Remove empty placeholders from text (for cases where no values are provided)
function p.removeEmptyPlaceholders(text)
    if not text then
        return text
    end
   
    -- Remove any remaining $VARIABLE$ placeholders that weren't filled
    local result = text:gsub("%$[A-Z_]+%$", "")
   
    -- Clean up any resulting double spaces or awkward punctuation
    result = result:gsub("%s+", " ")  -- Multiple spaces to single space
    result = result:gsub("^%s+", "")  -- Leading whitespace
    result = result:gsub("%s+$", "")  -- Trailing whitespace
    result = result:gsub("%s+%.", ".")  -- Space before period
    result = result:gsub("is a%s+based", "is based")  -- Fix "is a  based" to "is based"
    result = result:gsub("is a%s+in", "is in")  -- Fix "is a  in" to "is in"
      
      
     return result
     return result
Retrieved from "https://staging.icannwiki.org/Module:TemplateStarter"