Module:Val: Difference between revisions

-- TODO put '0' in front of number like '.123'; remove signs from input uncertainties
local getArgs
local delimit_groups = require('Module:Gapnum').groups

-- Specific message for {{Val}} errors
local function valerror(msg, nocat)
 if is_test_run then  -- LATER remove
  return 'Error: "' .. msg .. '"'
 end
 local ret = mw.html.create('strong')
       :addClass('error')
       :wikitext('Error in {{Val}}: ' .. msg)
 -- Not in talk, user, user_talk, or wikipedia_talk
 if not nocat and not mw.title.getCurrentTitle():inNamespaces(1,2,3,5) then
  ret:wikitext('[[Category:Pages with incorrect formatting templates use]]')
 end
 return tostring(ret)
end

-- true/false whether or not the string is a valid number
-- ignores parentheses and parity symbolts
local function validnumber(n)
 -- Look for a number that may be surrounded by parentheses or may have +/-
 n = mw.ustring.match(tostring(n), '^%(?[±%-%+]?([%d\.]+)%)?$')
 return tonumber(n) ~= nil
end

local function get_builtin_unit(unitcode, definitions)
 -- Return table of information for the specified built-in unit, or nil if not known.
 -- Each defined unit code must be followed by two spaces (not tab characters).
 local _, pos = definitions:find('\n' .. unitcode .. '  ', 1, true)
 if pos then
  local endline = definitions:find('\n', pos, true)
  if endline then
   local result = {}
   local n = 0
   local text = definitions:sub(pos, endline - 1)
   for item in (text .. '  '):gmatch('(%S[^\n]-)%s%s') do
    if item == 'NOSPACE' then
     result.nospace = true
    elseif item == 'ANGLE' then
     result.isangle = true
     result.nospace = true
    else
     n = n + 1
     if n == 1 then
      result.symbol = item
     elseif n == 2 then
      result.link = item
     else
      break
     end
    end
   end
   if n == 2 then
    return result
   end
   -- Ignore invalid definition, treating it as a comment.
  end
 end
end

local function convert_lookup(ucode, options)
 local lookup = require('Module:Convert/sandbox')._unit
 return lookup(ucode, { value = options.value, link = options.want_link })
end

local function get_unit(ucode, value, want_link, want_longscale)
 local data = mw.loadData('Module:Val/units')
 local result = want_longscale and
  get_builtin_unit(ucode, data.builtin_units_long_scale) or
  get_builtin_unit(ucode, data.builtin_units)
 local convert_unit = convert_lookup(ucode, { value = value, link = want_link })
 if result then
  -- Have: result.symbol + result.link + result.isangle + result.nospace
  if want_link then
   result.text = '[[' .. result.link .. '|' .. result.symbol .. ']]'
  else
   result.text = result.symbol
  end
  result.sortkey = convert_unit.sortkey
 else
  result = {
   text = convert_unit.text,
   sortkey = convert_unit.sortkey,
  }
 end
 return result
end

local function makeunit(ucode, options)
 -- Return wikitext, sortkey for the requested unit and options.
 -- TODO The sortkey does not account for any per unit.
 local function bracketed(ucode, text)
  return ucode:find('[*./]') and '(' .. text .. ')' or text
 end
 options = options or {}
 local unit = get_unit(ucode, options.value, options.link, options.longscale)
 local text = unit.text
 local percode = options.per
 if percode then
  local perunit = get_unit(percode, 0, options.per_link, options.longscale)
  text = bracketed(ucode, text) .. '/' .. bracketed(percode, perunit.text)
 end
 if not unit.nospace then
  text = ' ' .. text
 end
 return { text = text, isangle = unit.isangle, sortkey = unit.sortkey }
end

-- TODO: Add other format options
local function delimit(n, fmt)
 local prefix, num
 if not fmt then fmt = '' end
 fmt = fmt:lower()
 -- look for + or - preceding the number
 if n:find('[-+]') then
  prefix, num = string.match(n, '([-+])([%d.]+)')
 else
  num = n
 end

 -- integer and decimal parts of number
 -- if there is no decimal part, delimit_groups only returns 1 table
 local ipart, dpart = delimit_groups(num)
 if fmt == 'commas' then
  num = table.concat(ipart, ',')
  if dpart then
   dpart = table.concat(dpart)
   num = num .. '.' .. dpart
  end
 elseif fmt == 'none' then
  -- TODO Why not use original num?
  num = table.concat(ipart)
  if dpart then
   dpart = table.concat(dpart)
   num = num .. '.' .. dpart
  end
 else
  -- Delimit with a small gap by default.
  num = {}
  num[1] = table.remove(ipart, 1)
  for _, v in ipairs(ipart) do
   table.insert(num, '<span style="margin-left:.25em">' .. v .. '</span>')
  end
  if dpart then
   table.insert(num, '.' .. table.remove(dpart, 1))
   for _, v in ipairs(dpart) do
    table.insert(num, '<span style="margin-left:.25em">' .. v .. '</span>')
   end
  end
  num = table.concat(num)
 end

 -- add prefix back if it had one
 if prefix then
  -- change hyphen to proper minus sign
  if prefix == '-' then
   prefix = '−'
  end
  num = prefix .. num
 end

 return tostring(num)
end

local function _main(number, uncertainty, unit_spec, misc_tbl)
 local e_10 = misc_tbl.e
 local fmt = misc_tbl.fmt

 -- Unit
 local unit_table, sortkey
 if unit_spec.u then
  unit_table = makeunit(unit_spec.u, {
      link = unit_spec.link,
      per = unit_spec.per,
      per_link = unit_spec.per_link,
      value = (tonumber(number.n) or 1) * (e_10 and 10^e_10 or 1),
      longscale = nil,  -- TODO set from 'long scale' parameter
     })
  sortkey = unit_table.sortkey
 else
  sortkey = convert_lookup('dummy', { value = number.n }).sortkey
 end

 -- Uncertainty
 local unc_text
 local uncU, uncL = uncertainty.upper, uncertainty.lower -- TODO caller should ensure uncU and uncL have no sign
 -- The entire number needs to be wrapped in parentheses if:
 --   the exponent parameter (e) is defined AND
 --   no lower uncertainty is defined AND
 --   upper uncertainty is defined and contains no parentheses
 local paren_wrap = e_10 and (not uncL and (uncU and not uncU:find('%(')))
 local paren_uncertainty
 if uncU then
  if uncL then
   local mSu = require('Module:Su')._main  -- sup/sub format
   uncU = '+' .. delimit(uncU, fmt) .. (uncertainty.upperend or '') 
   uncL = '−' .. delimit(uncL, fmt) .. (uncertainty.lowerend or '') 
   if unit_table and unit_table.isangle then
    uncU = uncU .. unit_table.text
    uncL = uncL .. unit_table.text
   end
   unc_text = '<span style="margin-left:0.3em;">' .. mSu(uncU, uncL) .. '</span>'
  else
   -- Look for parentheses surrounding upper uncertainty
   paren_uncertainty = (uncU:sub(1, 1) == '(' and uncU:sub(-1) == ')')
   if paren_uncertainty then
    unc_text = '(' .. delimit(uncU:sub(2, -2), fmt) .. ')'
   else
    unc_text = '<span style="margin-left:0.3em;margin-right:0.15em">±</span>' .. delimit(uncU, fmt) .. '</span>'
   end
   if uncertainty.errend then
    unc_text = unc_text .. uncertainty.errend
   end
   if unit_table and unit_table.isangle then
    unc_text = unc_text .. unit_table.text
   end
  end
 end
 local e_text, n_text
 if number.n then
  n_text = delimit(number.n, fmt) .. (number.nend  or '')
  if not paren_uncertainty and unit_table and unit_table.isangle then
   n_text = n_text .. unit_table.text
  end
 else
  n_text = ''
  e_10 = e_10 or '0'
 end
 if e_10 then
  e_text = '10<sup>' .. delimit(e_10) .. '</sup>'
  if number.n then
   e_text = '<span style="margin-left:0.25em;margin-right:0.15em">×</span>' .. e_text
  end
 else
  e_text = ''
 end
 return table.concat({
   '<span class="nowrap">',
   misc_tbl.prefix or '',
   paren_wrap and '(' or '',
   n_text,
   unc_text or '',
   paren_wrap and ')' or '',
   e_text,
   (unit_table and not unit_table.isangle) and unit_table.text or '',
   misc_tbl.suffix or '',
   '</span>'
  })
end

local function main(frame)
 if not getArgs then
  getArgs = require('Module:Arguments').getArgs
 end
 local args = getArgs(frame, {wrappers = { 'Template:Val', 'Template:Val/sandboxlua' }})
 local number = {n=args[1], nend=args['end']}
 local nocat = args.nocategory

 -- Error checking
 if args[1] and not validnumber(args[1]) then
  return valerror('first argument is not a valid number.',nocat)
 end
 if args[2] and not validnumber(args[2]) then
  return valerror('second argument is not a valid number.',nocat)
 end
 if args[3] and not validnumber(args[3]) then
  return valerror('third argument is not a valid number.',nocat)
 end
 if args.e and not validnumber(args.e) then
  return valerror('exponent argument (<b>e</b>) is not a valid number.',nocat)
 end
 if args.u and args.ul then
  return valerror('unit (<b>u</b>) and unit with link (<b>ul</b>) are both specified, only one is allowed.',nocat)
 end
 if args.up and args.upl then
  return valerror('unit per (<b>up</b>) and unit per with link (<b>upl</b>) are both specified, only one is allowed.',nocat)
 end

 -- Group arguments into related categories and unpack when needed
 local uncertainty = {
   upper = args[2],
   lower = args[3],
   errend = args.errend,
   upperend = args['+errend'],
   lowerend = args['-errend'],
  }
 local unit_spec = {
   u = args.ul or args.u,
   link = args.ul ~= nil,
   per = args.upl or args.up,
   per_link = args.upl ~= nil,
  }
 local misc_tbl = {
   e = args.e,
   prefix = args.p,
   suffix = args.s,
   fmt = args.fmt or '',
   nocat = args.nocategory,
  }
 return _main(number, uncertainty, unit_spec, misc_tbl)
end

return { main = main, _main = _main }