Module:ConvertIB

Documentation for this module may be created at Module:ConvertIB/doc

require('strict')
local p = {}
local getArgs = require('Module:Arguments').getArgs

-- Function to pull out values and units from numeric args
-- Returns:
--   values:  list of numeric values, or "false" if no numeric argument is given
--   units: list of units (str)
--   value: if there is a last numeric value unpaired with a unit, it becomes the precision
--   anyValue: whether there is a non-false value in the values list
local function parseValuesUnits(args)
	local values = {}
	local units = {}
	local indx = 1
	local value = nil
	local anyValue = false
	-- loop through numeric arguments in pairs
	while args[indx] or args[indx+1] do
		value = args[indx]
		anyValue = anyValue or value
		-- if there is a unit, save in output lists
		if args[indx+1] then
			table.insert(values, value or false)
			table.insert(units, args[indx+1])
			value = nil
		end
		indx = indx+2
	end
	return values, units, value, anyValue
end

-- Function to identify multiple units and rewrite them as new input or output groups
-- Args:
--   values, units: numeric values and units, as lists with same length
-- Returns:
--   newValues, newUnits: same lists rewritten
local function parseMultiples(values, units)
	local newValues = {}
	local newUnits = {}
	local i = 1
	-- we will search for multiples with up to 4 entries (depending on length)
	local maxMultiple = math.min(4,#units-1)
	local valueFound = false -- flag to suppress second (and later) input values
	--- Hack for handling "stone": check if only value supplied is "lb"
	local onlyPounds = true
	for i = 1, #units do
		if values[i] and units[i] ~= 'lb' then
			onlyPounds = false
			break
		end
	end
    local multiple = mw.loadData('Module:ConvertIB/data').multiple
	-- sweep through units
	while i <= #units do
		-- determine index of last possible unit that could contain a multiple
		local last_unit = math.min(i+maxMultiple-1,#units)
		local multipleFound = false
		-- try from longest multiple down to double multiple (prefer longest ones)
		for j = last_unit, i+1, -1 do
			local key = table.concat({unpack(units,i,j)}, '')
			if multiple[key] then
				-- we found a multiple unit
				multipleFound = true
				-- Hack for "stone": add either 'lb' or multiple unit string to output units
				--    depending on whether 'lb' was the only unit string with a value
				if mw.ustring.sub(key,1,2) == 'st' then
					table.insert(newValues, false)
					table.insert(newUnits, onlyPounds and key or 'lb')
				end
				-- if there are any value in the span of the multiple,
				-- then the multiple is an input
				-- assume all missing values after the first are zero
				local firstValueFound = false
				for k = i, j do
					firstValueFound = not valueFound and (firstValueFound or values[k])
					if firstValueFound then
						table.insert(newValues, values[k] or 0)
						table.insert(newUnits, units[k])
					end
				end
				valueFound = valueFound or firstValueFound
				-- if no values in the span of the multiple,
				-- then the multiple is an output. Insert combined string as output unit
				if not firstValueFound then
					table.insert(newValues, false)
					table.insert(newUnits, key)
				end
				i = j+1
				break
			end
		end
		--- If no multiple unit was found, insert value[i] and unit[i] into rewritten lists
		if not multipleFound then
			if valueFound then
				table.insert(newValues, false) -- skip writing value if it is a duplicate
			else
				table.insert(newValues,values[i])
				valueFound = values[i]
			end
			table.insert(newUnits, units[i])
			i = i+1
		end
	end
	return newValues, newUnits			
end

-- Call {{convert}} with args
local function callConvert(args)
	local frame = mw.getCurrentFrame()
	return frame:expandTemplate{title='Convert', args=args}
end

-- Implement {{convinfobox}}
function p._convert(args)
	-- find all values and units in numeric args (and the precision, if it exists)
	local values, units, precision, anyValue = parseValuesUnits(args)
	-- bail if no values at all
	if not anyValue then
		return nil
	end
	-- rewrite values and units if multiple units are found
	values, units = parseMultiples(values, units)
	-- sort input and outputs into different buckets
	local input_values = {}
	local input_units = {}
	local output_units = {}
	for i = 1, #units do
		if values[i] then
			table.insert(input_values, values[i])
			table.insert(input_units, units[i])
		else
			table.insert(output_units, units[i])
		end
	end
	-- bail if nothing to convert
	if #input_values == 0 or #output_units == 0 then
		return nil
	end
	-- assemble argument list to {{convert}}
	local innerArgs = {}
	-- First, pass all input unit(s)
	for i, v in ipairs(input_values) do
		table.insert(innerArgs,v)
		table.insert(innerArgs,input_units[i])
	end
	-- Then the output unit(s) [concatenated as single argument]
	table.insert(innerArgs,table.concat(output_units,"+"))
	if precision then
		table.insert(innerArgs,precision) -- last non-nil value contains precision
	end
	-- now handle all non-numeric arguments, passing to {{convert}}
	innerArgs.abbr = 'on'  -- abbr=on by default
	for k, v in pairs(args) do
		if not tonumber(k) then
			innerArgs[k] = v
		end
	end
    return callConvert(innerArgs)
end

local function impUnitPref(pref,country)
    --- lower case all arguments
    pref = pref and mw.ustring.lower(pref)
    country = country and mw.ustring.lower(country)
    --- determine imperial unit by going thru arguments in priority order
    if pref and pref ~= 'dunam' then
        local impPref = mw.loadData('Module:ConvertIB/data').impPref
        return impPref[pref]
    elseif country then
        return mw.ustring.find(country,"united states",1,true) 
               or mw.ustring.find(country,"united kingdom",1,true)
    end
    return false
end

-- Implement {{Infobox settlement/areadisp}}
function p._area(args)
    local pref = args['pref']
    local country = args['name']
    local impus = impUnitPref(pref, country)
    local km2 = args['km2']
    local mi2 = args['mi2'] or args['sqmi']
    local ha = args['ha']
    local acre = args['acre']
    local dunam = args['dunam'] or args['dunum']
    local link = args['link']
    local innerArgs = {}
    innerArgs.abbr = 'on'
    innerArgs.order = 'out'
    if km2 then
        table.insert(innerArgs,km2)
        table.insert(innerArgs,'km2')
    elseif mi2 then
        table.insert(innerArgs,mi2)
        table.insert(innerArgs,'sqmi')
    end
    if km2 or mi2 then
        table.insert(innerArgs,impus and 'sqmi km2' or 'km2 sqmi')
        return callConvert(innerArgs)
    end
    if ha then
        table.insert(innerArgs,ha)
        table.insert(innerArgs,'ha')
    elseif acre then
        table.insert(innerArgs,acre)
        table.insert(innerArgs,'acre')
    end
    if ha or acre then
        table.insert(innerArgs,impus and 'acre ha' or 'ha acre')
        return callConvert(innerArgs)
    end
    if dunam then
        table.insert(innerArgs,dunam)
        table.insert(innerArgs,'dunam')
        pref = pref and mw.ustring.lower(pref)
        local order = pref == 'dunam' and 'dunam ' or ''
        dunam = mw.getContentLanguage():parseFormattedNumber(dunam)
        if impus then
            order = order..(dunam and dunam < 2589 and 'acre ha' or 'sqmi km2')
        else
            order = order..(dunam and dunam < 1000 and 'ha acre' or 'km2 sqmi')
        end
        table.insert(innerArgs,order)
        local yesNo = require('Module:Yesno')
        if yesNo(link,true) and link ~= 'none' then
            innerArgs.lk = 'in'
        end
        return callConvert(innerArgs)
    end
    return nil
end

-- Implement {{Infobox settlement/lengthdisp}}
function p._length(args)
    local pref = args['pref']
    if pref == 'dunam' then  -- ignore dunam pref for this function
        pref = nil
    end
    local country = args['name']
    local impus = impUnitPref(pref, country)
    local km = args['km']
    local mi = args['mi']
    local m = args['m']
    local ft = args['ft']
    local innerArgs = {}
    innerArgs.abbr = 'on'
    innerArgs.order = 'out'
    if km then
        table.insert(innerArgs,km)
        table.insert(innerArgs,'km')
    elseif mi then
        table.insert(innerArgs,mi)
        table.insert(innerArgs,'mi')
    end
    if km or mi then
        table.insert(innerArgs,impus and 'mi km' or 'km mi')
        return callConvert(innerArgs)
    end
    if m then
        table.insert(innerArgs,m)
        table.insert(innerArgs,'m')
    elseif ft then
        table.insert(innerArgs,ft)
        table.insert(innerArgs,'ft')
    end
    if m or ft then
        table.insert(innerArgs,impus and 'ft m' or 'm ft')
        return callConvert(innerArgs)
    end
    return nil
end

--Compute number of significant digits in a numeric string
local function computeSigFig(s)
    local num_str = string.match(tostring(s), '^[+-]?[%d%.,]+%d*')
    if not num_str then
       return 0
    end
    
    -- Strip leading signs
    num_str = string.gsub(num_str, '^[+-]', '')
    -- Strip commas
    num_str = string.gsub(num_str, ',', '')
    -- Strip leading zeros
    num_str = string.gsub(num_str, '^0*', '')

    if num_str == '' then
        return 0
    end
    
    -- If there's a decimal point, all trailing zeros are significant.
    if string.find(num_str, '%.') then
        return #string.gsub(num_str, '%.', '') -- Count all digits after removing decimal
    end

    -- If no decimal point, trailing zeros are not significant.
    -- Count all digits up to the last non-zero one.
    num_str = string.gsub(num_str, '0+$', '')
    
    return #num_str
end

-- Implement {{Infobox settlement/densdisp}}
-- Returns table:
--   density = computed value if no error
--   error = error string if error. 
--      These are only errors detected in this code, {{convert}} does its own error handling
function p._density(args)
    local result = {}
    local lang = mw.getContentLanguage()
    local pref = args['pref']
    if pref == 'dunam' then  -- ignore dunam pref for this function
        pref = nil
    end
    local country = args['name']
    local per_km2 = args['/km2']
    local per_mi2 = args['/mi2'] or args['/sqmi']
    local impus = impUnitPref(pref, country, per_km2, per_mi2)
    local per_km2_value = lang:parseFormattedNumber(per_km2)
    local per_mi2_value = lang:parseFormattedNumber(per_mi2)
    local innerArgs = {}
    innerArgs.abbr = 'on'
    if per_km2_value or per_mi2_value then
        innerArgs.order = 'out'
        if per_km2_value then
            table.insert(innerArgs,per_km2_value)
            table.insert(innerArgs,'/km2')
        else
            table.insert(innerArgs,per_mi2_value)
            table.insert(innerArgs,'/sqmi')
        end
        table.insert(innerArgs,impus and '/sqmi /km2' or '/km2 /sqmi')
        result.density = callConvert(innerArgs)
        return result
    end
    if per_km2 ~= 'auto' and per_mi2 ~= 'auto' then
        -- automatic computation not requested, fail silently
        return result
    end
    if not args['pop'] then
        -- fail silently if no population given
        return result
    end
    local areaSigFig
    local areaValue
    local areaUnit
    for _, unit in ipairs({'km2','mi2','sqmi','ha','acre','dunam','dunum'}) do
        local value = lang:parseFormattedNumber(args[unit])
        if value then
            if value <= 0 then
                result.error = unit.." value not positive"
                return result
            end
            areaValue = value
            areaUnit = unit
            areaSigFig = computeSigFig(args[unit])
            break
        elseif args[unit] then
            result.error = "Malformed "..unit.." value"
            return result
        end
    end
    if not areaSigFig then
        -- fail silently if no area given
        return result
    end
    if areaSigFig == 0 then
        result.error = "Malformed area string"
        return result
    end
    local popValue = lang:parseFormattedNumber(args['pop'])
    if not popValue then
        result.error = "Malformed population value"
        return result
    end
    if popValue < 0 then
        result.error = "Negative population value"
        return result
    end
    table.insert(innerArgs,popValue/areaValue)
    table.insert(innerArgs,'/'..areaUnit)
    local popSigFig = computeSigFig(args['pop'])
    local sigFig = popSigFig < areaSigFig and popSigFig or areaSigFig
    if sigFig < 2 then
        sigFig = 2
    end
    innerArgs.sigfig = sigFig
    innerArgs.disp = 'out'
    table.insert(innerArgs,'/km2')
    local metric = callConvert(innerArgs)
    innerArgs[3] = '/sqmi'
    local imperial = callConvert(innerArgs)
    if impus then
        result.density = string.format("%s (%s)",imperial,metric)
    else
        result.density = string.format("%s (%s)",metric,imperial)
    end
    return result
end

function p.convert(frame)
	local args = getArgs(frame)
	return p._convert(args) or ""
end

function p.area(frame)
    local args = getArgs(frame)
    return p._area(args) or ""
end

function p.length(frame)
    local args = getArgs(frame)
    return p._length(args) or ""
end

function p.density(frame)
    local args = getArgs(frame)
    local result = p._density(args)
    if result.density then
        return result.density
    end
    if result.error then
        local warning = require('Module:If_preview')._warning
        local result = warning({result.error})
        if mw.title.getCurrentTitle().namespace == 0 then
            result = result..'[[Category:Pages using infobox settlement with bad density arguments]]'
        end
        return result
    end
    return ''
end

return p