Module:ItemVariants

Module documentation[view][edit][history][purge]

This documentation is transcluded from Module:ItemVariants/doc. Changes can be proposed in the talk page.

Module:ItemVariants is shared across the Star Citizen Wikis.

This module is shared across the Star Citizen Wikis. Any changes should also be relayed to the GitHub repository.

Module:ItemVariants loads configuration from Module:ItemVariants/config.json.

This module can be configurated from the config.json subpage.

This module is unused.

This module is neither invoked by a template nor required/loaded by another module. If this is in error, make sure to add {{Documentation}}/{{No documentation}} to the calling template's or parent's module documentation.

Module:ItemVariants requires Module:Arguments and strict.

Module:ItemVariants loads styles from Module:ItemVariants/styles.css.

ExpandFunction list
L 11 — removeWordsFromString L 43 — makeSmwQueryObject L 83 — methodtable.getSmwData L 106 — methodtable.out L 128 — ItemVariants.new L 140 — ItemVariants.outputTable L 155 — ItemVariants.test

---

require( 'strict' )

local ItemVariants = {}

local metatable = {}
local methodtable = {}

metatable.__index = methodtable


local function removeWordsFromString(inputString, wordsToRemove)
    -- Split the input string into individual words
    local words = {}
    for word in inputString:gmatch("%S+") do
        table.insert(words, word)
    end
    
    -- Create a set of words to remove
    local wordsSet = {}
    for word in wordsToRemove:gmatch("%S+") do
        wordsSet[word] = true
    end
    
    -- Filter out words that need to be removed
    local cleanedWords = {}
    for _, word in ipairs(words) do
        if not wordsSet[word] then
            table.insert(cleanedWords, word)
        end
    end
    
    -- Join the cleaned words back into a string
    local cleanedString = table.concat(cleanedWords, " ")
    
    return cleanedString
end


--- Creates the object that is used to query the SMW store
---
--- @param page string the item page containing data
--- @return table
local function makeSmwQueryObject( self, page )
    local itemBaseVariantName = 'Item base variant name'
    
    local itemBaseVariant =  mw.smw.ask{
		mw.ustring.format( '[[-%s::%s]]', itemBaseVariantName, page ),
		'?#-=name',
		'?Page Image#-=image',
		limit = 1
	}
	
	if type( itemBaseVariant ) ~= 'table' or #itemBaseVariant ~= 1 then
		return ''
	end
	
	mw.logObject( itemBaseVariant, 'itemBaseVariant' )

	itemBaseVariant = itemBaseVariant[ 1 ]
	self.itemBaseVariant = itemBaseVariant

    local query = {
        '[[:+]]',
        mw.ustring.format(
        	'<q>[[%s::%s]] || [[%s::%s]] || [[-%s::%s]]</q>',
        	itemBaseVariant.name,
        	page,
        	itemBaseVariantName,
        	itemBaseVariant.name,
        	itemBaseVariantName,
        	itemBaseVariant.name
        ),
        '?#-=name',
        '?Page Image#-=image'
    }

    return query
end


--- Queries the SMW Store
--- @return table|nil
function methodtable.getSmwData( self, page )
    --mw.logObject( self.smwData, 'cachedSmwData' )
	-- Cache multiple calls
    if self.smwData ~= nil then
        return self.smwData
    end

	local smwData = mw.smw.ask( makeSmwQueryObject( self, page ) )
	table.insert( self.itemBaseVariant, 1, smwData )

    if smwData == nil or smwData[ 1 ] == nil then
        return nil
    end
	
	mw.logObject( smwData, 'getSmwData' )
    self.smwData = smwData

    return self.smwData
end


--- Generates wikitext needed for the template
--- @return string
function methodtable.out( self )
	local smwData = self:getSmwData( self.page )

	if smwData == nil then
        return 'some error message'
	end

	--for _, variant in ipairs( smwData ) do
	--	local variantName = variant.name

	--	if baseItemName ~= nil then
	--		variantName = removeWordsFromString( variantName, baseItemName )
	--		variantName = mw.text.trim( variantName )
	--	end
	--	mw.log( variantName )
	--end
end


--- New Instance
---
--- @return table ItemVariants
function ItemVariants.new( self, page )
    local instance = {
        page = page or nil
    }

    setmetatable( instance, metatable )

    return instance
end


--- Parser call for generating the table
function ItemVariants.outputTable( frame )
    local args = require( 'Module:Arguments' ).getArgs( frame )
    local page = args[ 1 ] or mw.title.getCurrentTitle().rootText

    local instance = ItemVariants:new( page )
    local out = instance:out()

    return out
end


--- For debugging use
---
--- @param page string page name on the wiki
--- @return string
function ItemVariants.test( page )
    local instance = ItemVariants:new( page )
    local out = instance:out()

    return out
end


return ItemVariants