Módulo:Formato

A documentação para este módulo pode ser criada na página Módulo:Formato/doc

-- Módulo dedicado a formatação de texto

local fun = {}

-- Formatando números
-- Imita o comportamento da palavra mágica formatnum, sem parâmetro R
function fun.formatnum(frame)
    return fun.do_formatnum(frame:getParent().args)
end

function fun.do_formatnum(arguments)
    local resultado = ""
    local number = ""
    -- Verificação do parâmetro
    if(type(tonumber(arguments[1])) == "number") then
        number = arguments[1]
   
        -- Extração das partes do nome
        local _, _, minus, intPart, point, fracPart = string.find(number,"^([^0-9.]?)0*(%d*)(\.?)(%d*)$")
       
        -- Sinal menos
        resultado = resultado .. minus
        -- Parte inteira
        if(#intPart > 0) then
            local index = #intPart
            for digit in string.gfind(intPart, "%d") do
                resultado = resultado .. digit
                -- espaço a cada três dígitos
                if((index % 3) == 1 and index > 1) then
                    resultado = resultado .. " "
                end
                index = index - 1
            end
        else
            -- Adicione um zero se a parte decimal estiver vazia
            resultado = resultado .. "0"
        end
        -- Virgula
        if(point ~= "") then
            resultado = resultado .. ","
        end
        -- Parte fraccionário
        resultado = resultado .. fracPart
    else
        resultado = (arguments[1] or "")
    end
   
    return resultado
end

-- Formatando números com unidade
-- Baseado na predefinição: unidade, mas sem limitação do número de argumentos
function fun.unidade(frame)
    return fun.do_unidade(frame:getParent().args)
end

-- Realização da função anterior
function fun.do_unidade(arguments)
    local resultado = ""
   
    -- Formatando o valor principal
    if(arguments[1] ~= nil) then
        resultado = fun.do_formatnum{arguments[1]}
    end
   
    -- Formato do poder de 10 possíveis
    if(arguments.e ~= nil) then
        resultado = resultado .. fun.do_x10{arguments.e}
    end
   
    -- Curso de unidades e expositores
    local index = 2
    while(arguments[index] ~= nil) do
        if (index == 2) then
            -- Primeira unidade: espaço sem quebra
            resultado = resultado .. " "
        else
            -- As seguintes unidades: ponto médio
            resultado = resultado .. "⋅"
        end
       
        -- Mostra-se a unidade
        resultado = resultado .. arguments[index]
       
        -- Possível expositor
        if(arguments[index+1] ~= nil) then
            resultado = resultado .. fun.do_expo{arguments[index+1]}
        end
       
        index = index + 2
    end
   
    -- Sem retorno para a linha
    resultado = "<span class=\"nowrap\">" .. resultado .. "</span>"
   
    return resultado
end

-- Formatação de expositores
-- Baseado na Predefinição:Exp
function fun.expo(frame)
    return fun.do_expo(frame:getParent().args)   
end

-- Realização da função anterior
function fun.do_expo(arguments)
    local resultado = ""
    if(arguments[1] ~= nil) then
        resultado = resultado .. arguments[1]
    end
    resultado = "<sup>" .. resultado .. "</sup>"
   
    return resultado
end

-- Formatando os poderes de 10
-- Baseado na predefinição: x10
function fun.x10(frame)
    return fun.do_x10(frame:getParent().args)   
end

-- Realização da função anterior
function fun.do_x10(arguments)
    local resultado = "×10" .. fun.do_expo{arguments[1]}
    return resultado
end

-- Exibição de um valor em parsecs
-- Baseado na Predefinição: Parsec
function fun.parsec(frame)
    return fun.do_parsec(frame:getParent().args)   
end

-- Realização da função anterior
function fun.do_parsec(arguments)
    local resultado = ""
       
    -- Unidades disponíveis
    local units = {
        pc = {"[[parsec|pc]]", [false] = {1, ""}, [true] = {1, ""}},
        kpc = {"[[Kiloparsec|kpc]]", [false] = {1000, ""}, [true] = {0.001, "milhão"}},
        mpc = {"[[Megaparsec|Mpc]]", [false] = {1, "milhão"}, [true] = {0.001, "bilião"}},
        gpc = {"[[Gigaparsec|Gpc]]", [false] = {1, "bilião"}, [true] = {1, "bilião"}}
    }
   
    -- Valor principal
    local resultadoVal = fun.do_formatnum{(arguments[1] or "")}
   
    -- Unidade utilizada
    local unitData = (units[arguments[2]] or units.pc)
   
    if(arguments.margem ~= nil or arguments.sup ~= nil) then
        -- margem possível
        if(arguments.margem ~= nil) then
            local resultadoMargem = "" ;
            if(tonumber(arguments.margem) ~= nil) then
                resultadoMargem = "<small>&plusmn;" .. arguments.margem .. "</small>"
            else
                resultadoMargem = arguments.margem
            end
            resultadoVal = resultadoVal .. resultadoMargem
        end
       
        -- Segundo valor possível
        if(arguments.sup ~= nil) then
            resultadoVal = resultadoVal .. " a&nbsp;" .. arguments.sup
        end
    else
        -- "Aproximadamente" se for um valor bruto apenas
    resultado = resultado .. "aproximadamente&nbsp;"
    end
    -- Exibição de valor
    resultado = resultado .. fun.do_unidade{resultadoVal,unitData[1]} .. " "
   
    -- Exibir conversão em anos-luz
    local numVal = tonumber(arguments[1])
    if(numVal ~= nil) then
        -- Outra ordem de magnitude é usada se o valor for muito grande
        local isBigVal = (numVal*3.2616 >= 1000)
        -- Valor em anos-luz
        local alVal = numVal*unitData[isBigVal][1]*3.2616
        -- Primeiro valor
        resultado = resultado .. "(&sim;" .. fun.do_formatnum{fun.do_estatisticaSignificativa{alVal,3}} .. "&nbsp;"
        if(arguments.sup ~= nil and tonumber(arguments.sup) ~= nil) then
            -- Segundo valor possível
            alVal = tonumber(arguments.sup)*unitData[isBigVal][1]*3.2616
            resultado = resultado .. "a&nbsp;" .. fun.do_formatnum{fun.do_estatisticaSignificativa{alVal,3}} .. "&nbsp;"
        end
        -- O último valor exibido (alVal) resulta em um plural?
        local unitFull = ""
        if(unitData[isBigVal][2] ~= "") then -- Você tem que ter uma palavra para colocar no plural
            if(alVal >= 1.995) then
                unitFull = "s"
            end
            unitFull = unitData[isBigVal][2] .. unitFull .. " de"
        end
        -- Mostra-se a unidade
        resultado = resultado .. unitFull .. "[[Ano-luz|a.l.]])" ;
    end
   
    return resultado
end

-- Exibição de um número com dígitos significativos
function fun.estatisticaSignificativa(frame)
    return fun.do_estatisticaSignificativa(frame:getParent().args) 
end

-- Realização da função anterior
-- Aviso, retorna uma string
-- Uso: fun.do_estatisticaSignificativa {valor, número de estatisticas grandes}

function fun.do_estatisticaSignificativa(arguments)
    local resultado = ""
    local value, digits = tonumber(arguments[1]), tonumber(arguments[2])
    if(value ~= nil and digits ~= nil) then
        local logVal = math.ceil(math.log10(value))
        local mult = 10^(digits-logVal)
        local rounded = math.floor(value*mult+0.5)/mult
        resultado = string.format("%." .. tostring(math.max(digits-logVal,0)) .. "f", rounded)
    end
    return resultado
end

-- Adiciona hyperlinks para palavras separadas por vírgulas, como as das propriedades Wikidata
function fun.ajustarLinks(frame)
    local arguments = frame:getParent().args
    local palavras = mw.text.split(arguments[2], ",")
    local links = table.concat(palavras, "]], [[")
    if links ~= nil and links ~= "" then
      return "[[" .. links .. "]]"
    else
      return ""
    end
end

return fun