모듈:GameJSONParser

모듈 설명문서[보기] [편집] [역사] [새로 고침]

아래 설명 내용은 모듈:GameJSONParser/설명문서에서 가져와서 보여주고 있습니다. (편집 | 역사)

getGameInfo

이 부분의 본문은 틀:게임 정보입니다.

getGamecard

이 부분의 본문은 틀:게임카드입니다.

getFeaturedCard

이 부분의 본문은 틀:추천평카드입니다.

도보시오

• 리버티게임:게임 메타데이터/스키마.json : 메타데이터 스키마
• 모듈:GameJSONParser/연구소

local p = {}

t = {
    find = function(table, func)
        for _, value in ipairs(table) do
            if func(value) then
                return value
            end
        end
        return nil
    end,

    map = function(table, func)
        local newTable = {}
        for i, value in ipairs(table) do
            newTable[i] = func(value)
        end
        return newTable
    end,

    filter = function(table, func)
        local newTable = {}
        for _, value in ipairs(table) do
            if func(value) then
                table.insert(newTable, value)
            end
        end
        return newTable
    end
}


-- 게임 메타데이터를 파싱하여 각 속성에 대해 적절한 포맷터를 사용하는 함수
function p._manualParser(scheme, propertyCases, gameMeta)
	return scheme
    -- local results = {}

--     -- 각 속성 케이스를 순회합니다.
--     for _, propertyCase in ipairs(propertyCases) do
--         -- 현재 속성의 유효성을 확인합니다.
--         local validatedGroup = propertyCase:validate(gameMeta,scheme)

--         if validatedGroup ~= false then
--             if #validatedGroup ~= 0 and type(validatedGroup[1]) ~= 'table' then
--                 validatedGroup = {validatedGroup}
--             end

--             for _, validated in ipairs(validatedGroup) do
--                 local resultString = propertyCase.formatter
--                 for _, v in ipairs(validated) do
--                     local key = v[1]
--                     local value = v[2]
--                     resultString = resultString:gsub("$" .. key, value)
--                 end
--                 table.insert(results, resultString)
--             end
--         end
--     end

--     return results
end

-- 첫번째 파라미터에 리버티게임:게임 메타데이터/스키마.json, 
-- 두번째 파라미터에 game.json 넣어서 게임 자동분류 사용 가능 
-- 아직 테스트되지 않음
function p.manualParse(frame)
    local scheme = mw.text.jsonDecode(frame.args[1])
    local gameMeta = mw.text.jsonDecode(frame.args[2])

    -- construct propertyCases table
    local propertyCases = {
        {
            key = "platform",
            formatter = "[[분류:$title 게임]]",
            validate = function(gameMeta, scheme)
                local platFormData = t.find(scheme["$defs"].platform.oneOf, function(platform)
                    return platform.const == gameMeta.platform
                end)
                if platFormData == nil then return false end
                return {{key = "title", value = platFormData.title}}
            end
        },
        {
            key = "abandon",
            formatter = "{{뱃지|버려진 게임}}",
            validate = function(gameMeta, scheme)
                return gameMeta.abandon or false
            end
        },
        {
            key = "construction",
            formatter = "{{뱃지|공사중|$value}}",
            validate = function(gameMeta, scheme)
                if not gameMeta.construction then return false end
                if gameMeta.construction == true then return {{key = "value", value = ""}} end
                return {{key = "value", value = gameMeta.construction}}
            end
        },
        {
            key = "progress",
            formatter = "[[분류:$title]]",
            validate = function(gameMeta, scheme)
                local progressData = t.find(scheme.properties.progress.oneOf, function(progress)
                    return progress.const == gameMeta.progress
                end)
                return {{key = "title", value = progressData.title}}
            end
        },
        {
            key = "rating",
            formatter = "[[분류:$title 게임]]",
            validate = function(gameMeta, scheme)
                local age = gameMeta.rating.libertygame.age
                local ageData = t.find(scheme.properties.rating.oneOf[2].properties.libertygame.properties.age.oneOf, function(ageData)
                    return ageData.const == age
                end)
                return {{key = "title", value = ageData.title}}
            end
        },
        {
            key = "repair",
            formatter = "{{뱃지|수리중}}",
            validate = function(gameMeta, scheme)
                if not gameMeta.repair then return false end
                if gameMeta.repair == true then return {{key = "value", value = ""}} end
                return {{key = "value", value = gameMeta.repair}}
            end
        },
        {
            key = "genre",
            formatter = "[[분류:$title 게임]]",
            validate = function(gameMeta, scheme)
                local genres = gameMeta.genre
                if type(genres) == "string" then genres = {genres} end
                local genreData = t.filter(t.map(genres, function(genre)
                    return t.find(scheme["$defs"].genre.oneOf, function(genreData)
                        return genreData.const == genre
                    end)
                end), function(genreData)
                    return genreData ~= nil
                end)

                return t.map(genreData, function(genreData)
                    return {key = "title", value = genreData.title}
                end)
            end
        }
    }

    local parsed = p._manualParser(scheme, propertyCases, gameMeta)
    return mw.text.jsonEncode(parsed)
    --return table.concat(parsed)
end


function p.testParser(frame)
    local jsonschema = require('모듈:Jsonschema')

    local validator = jsonschema.generate_validator {
        type = 'object',
        properties = {
          foo = { type = 'string' },
          bar = { type = 'number' },
        },
      }
      
    return mw.text.jsonEncode( validator{ foo='hello', bar=42 } )
end
 

function p.testImportJson(frame)
    local jsonschema = require('모듈:GameJSONParser/scheme.json')

      
    return mw.text.jsonEncode( jsonschema )
end
 

function p.test(frame)
    local jsonschema = require('모듈:Jsonschema')

    local validator = jsonschema.generate_validator {
        type = 'object',
        properties = {
          foo = { type = 'string' },
          bar = { type = 'number' },
        },
      }
      
    return mw.text.jsonEncode( validator{ foo='hello', bar=42 } )
end
 
function p.testjson(frame)
	local encoded = mw.text.jsonDecode(frame.args[1])
	return mw.text.jsonEncode(encoded["$defs"].platform.oneOf)
end
return p