Module:Version

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

This module depends on the following other modules:

• Module:No globals
• Module:Util
• Module:Cargo
• Module:Item util
• Module:Version/config

Templates

• {{Version}}
• {{Version history list}}
• {{Timeline of items}}

The above documentation is transcluded from Module:Version/doc. (edit | history)
Editors can experiment in this module's sandbox (create | mirror) and testcases (create) pages.
Subpages of this module.

local getArgs = require('Module:Arguments').getArgs
local util = require('Module:Util')

local error = error
local tostring = tostring
local tonumber = tonumber
local pairs = pairs

local string_format = string.format
local table_concat = table.concat

local mw_html = mw.html

local p = {}

-----

------------------------------------------------------------------------------------------------------
-- Template: Version

local version_map = {
    version = {
        datatype = 'String',
        property = 'Is version',
        validate = tostring,
    },
    release_date = {
        datatype = 'String',
        property = 'Has release date',
        validate = tostring,
    },
    major_part = {
        datatype = 'Integer',
        property = 'Has major version part',
        validate = tonumber,
    },
    minor_part = {
        datatype = 'Integer',
        property = 'Has minor version part',
        validate = tonumber,
    },
    patch_part = {
        datatype = 'Integer',
        property = 'Has patch version part',
        validate = tonumber,
    },
    revision_part = {
        datatype = 'String',
        property = 'Has revision version part',
        validate = tostring,
    },
    before = {
        datatype = 'String',
        property = 'Has version before',
        validate = tostring,
        show = function(this)
            local version = this.value
            local date = this.release_date
            if version and date then
                return string_format('← [[Version %s|%s]]<br>%s', version, version, date)
            else
                return ''
            end
        end,
    },
    after = {
        datatype = 'String',
        property = 'Has version after',
        validate = tostring,
        show = function(this)
            local version = this.value
            local date = this.release_date
            if version and date then
                return string_format('[[Version %s|%s]] →<br>%s', version, version, date)
            else
                return ''
            end
        end,
    },
}

local temp_map_for_cargo = {'version', 'release_date', 'major_part'}


p.version = function(frame)
    local args = getArgs(frame, {parentFirst = true})
    local frame = util.misc.get_frame(frame)

    --[[
    = p.version({
        before = '2.4.1a',
        patch = '2.4.1b',
        patchdate = 'October 18, 2016',
        after = '2.4.2',
    })
    --]]


    if not args.patch or not args.patchdate then
        error('Arguments "patch" and "patchdate" are required')
    end

    local version = util.cast.version(args.patch)

    local v_struct = util.Struct(version_map)

    v_struct:set('version', args.patch)
    v_struct:set('release_date', args.patchdate)

    local part_names = {'major_part', 'minor_part', 'patch_part', 'revision_part'}
    for i = 1, #part_names do
        local part = version[i]

        if part then
            v_struct:set(part_names[i], part)
        end
    end


    -- Check and set 'before' and 'after' args
    local edge_names = {'before', 'after'}
    for i = 1, #edge_names do
        local v = args[edge_names[i]]
        if v then
            local edge_version = util.cast.version(v, {return_type = 'string'})

            local query = {
                string_format('[[Is version::%s]] [[Has release date::+]]', edge_version),
                '?Has release date',
            }
            local results = util.smw.query(query, frame)
            if #results == 1 then
                v_struct:set(edge_names[i], edge_version)
                v_struct:set_prop(edge_names[i], 'release_date', results[1]['Has release date'])
            elseif #results > 1 then
                error('There are versions with the same name')
            end
        end
    end


    -- Set SMW and Cargo data
    local props_smw = {}
    local props_cargo = {
        _table = 'Versions',
    }
    for i, _ in pairs(v_struct.map) do
        local value = v_struct:get(i)
        if value then
            props_smw[v_struct:get_prop(i, 'property')] = value
        end
        --props_cargo[i] = value or ''
    end

    util.smw.set(frame, props_smw)


    for i = 1, #temp_map_for_cargo do
        local v = temp_map_for_cargo[i]
        props_cargo[v] = v_struct:get(v) or ''
    end

    -- mw.logObject(props_cargo)
    util.cargo.store(frame, props_cargo)


    -- Generate output
    -- todo: rework it somehow
    local release_date = frame:callParserFunction('#show: Version ' .. v_struct:get('version'), {'?Has release date'})

    local tbl = mw_html.create('table')
    tbl
        :addClass('wikitable successionbox')
        :tag('tr')
            :tag('th')
                :attr('colspan', 3)
                :wikitext('[[Version history|Version History]]')
                :done()
            :done()
        :tag('tr')
            :tag('td')
                :cssText('width: 30%')
                :wikitext(v_struct:show('before'))
                :done()
            :tag('td')
                :cssText('width: 40%')
                :wikitext(string_format('[[Version %s]]<br>%s', v_struct:get('version'), release_date))
                :done()
            :tag('td')
                :cssText('width: 30%')
                :wikitext(v_struct:show('after'))

    local cats = {
        'Versions',
    }

    return tostring(tbl) .. util.misc.add_category(cats)
end

-----

p.version_declare = function(frame)
    -- local args = getArgs(frame, {parentFirst = true})
    local frame = util.misc.get_frame(frame)

    local props = {
        _table = 'Versions',
    }

--    for i, _ in pairs(version_map) do
--        props[i] = _.datatype
--    end

    for i = 1, #temp_map_for_cargo do
        local v = temp_map_for_cargo[i]
        local _ = version_map[v]
        props[v] = _.datatype
    end

    --mw.logObject(props)

    return util.cargo.declare(frame, props)
end

-----

------------------------------------------------------------------------------------------------------
-- Template: Version history list

p.version_history_list = function(frame)
    local args = getArgs(frame, {parentFirst = true})
    local frame = util.misc.get_frame(frame)

    -- = p.version_history_list({conditions='[[Is version::~1*||~2*]]'})
    -- = p.version_history_list({conditions='[[Is version::~0.9*]]'})
    -- = p.version_history_list({conditions='[[Is version::~0.5*]]'})

    if args.conditions then
        args.conditions = args.conditions .. '[[Has release date::+]]'
    else
        args.conditions = '[[Is version::+]][[Has release date::+]]'
    end

    local query = {
        args.conditions,
        '?Is version',
        '?Has release date',
        sort = 'Has release date, Is version',
        order = 'desc, desc',
        link = 'none',
        offset = 0,
    }

    local results = {}
    repeat
        local result = util.smw.query(query, frame)
        local length = #result
        query.offset = query.offset + length

        for i = 1, length do
            results[#results + 1] = result[i]
        end
    until length < 1000

    local out = {}
    local last_minor_version, current_list

    for i = 1, #results do
        local result = results[i]
        local date = result['Has release date']
        local version = result['Is version']

        local v = util.cast.version(result['Is version'])
        local minor_version = table_concat({v[1], v[2], v[3]}, '.') -- todo: rework it

        if minor_version ~= last_minor_version then
            if current_list ~= nil then
                out[#out + 1] = tostring(current_list)
            end

            out[#out + 1] = string_format('===Version %s===', minor_version)
            current_list = mw_html.create('ul')
        end

        current_list:tag('li'):wikitext(string_format('%s &ndash; [[Version %s]]', date, version))

        -- save the last list
        if i == #results and current_list ~= nil then
            out[#out + 1] = tostring(current_list)
        end

        last_minor_version = minor_version
    end

    return table_concat(out, '\n')
end

-----

p.version_history_list_2 = function(frame)
    local args = getArgs(frame, {parentFirst = true})
    local frame = util.misc.get_frame(frame)

    -- = p.version_history_list({conditions='[[Is version::~1*||~2*]]'})
    -- = p.version_history_list({conditions='[[Is version::~0.9*]]'})
    -- = p.version_history_list({conditions='[[Is version::~0.5*]]'})

    if args.conditions then
        args.conditions = args.conditions .. '[[Has release date::+]]'
    else
        args.conditions = '[[Is version::+]] [[Has release date::+]]'
    end

    local query = {
        args.conditions,
        '?Is version',
        '?Has release date',
        '?Has major version part',
        '?Has minor version part',
        '?Has patch version part',
--        '?Has revision version part',
        sort = 'Has major version part, Has minor version part, Has patch version part, Is version',
        order = 'desc, desc, desc, desc',
        link = 'none',
        offset = 0,
    }

    local results = {}
    repeat
        local result = util.smw.query(query, frame)
        local length = #result
        query.offset = query.offset + length

        for i = 1, length do
            results[#results + 1] = result[i]
        end
    until length < 1000

--    mw.logObject(results)

    local out = {}
    local last_minor_version, current_list

    for i = 1, #results do
        local result = results[i]
        local date = result['Has release date']
        local version = result['Is version']

        local patch_version = string_format('%s.%s.%s',
            result['Has major version part'], result['Has minor version part'], result['Has patch version part'])

        if patch_version ~= last_minor_version then
            if current_list ~= nil then
                out[#out + 1] = tostring(current_list)
            end

            out[#out + 1] = string_format('===Version %s===', patch_version)
            current_list = mw_html.create('ul')
        end

        current_list:tag('li'):wikitext(string_format('%s &ndash; [[Version %s]]', date, version))

        -- save the last list
        if i == #results and current_list ~= nil then
            out[#out + 1] = tostring(current_list)
        end

        last_minor_version = patch_version
    end

    return table_concat(out, '\n')
end

-----

return p