Category talk:Wren-fmt: Difference between revisions

===Source code===

/* Conv contains routines which do conversions between types. */

class Conv {

// All possible digits (upper case).

static upperDigits { "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" }

// Maximum safe integer = 2^53 - 1.

static maxSafeInt { 9007199254740991 }

// Converts an integer to a numeric ASCII string with a base between 2 and 36.

static itoa(n, b) {

return ((neg) ? "-" : "") + res[-1..0]

}

// Private helper function. Converts ASCII string to upper case.

// As itoa(n, b) but resulting digits are upper case.

static Itoa(n, b) { (b < 11) ? itoa(n, b) : upper_(itoa(n, b)) }

// Converts a numeric ASCII string with a base between 2 and 36 to an integer.

static atoi(s, b) {

if (!(s is String && s != "" && s.count == s.bytes.count)) Fiber.abort("Argument must be an ASCII string.")

if (s == "") Fiber.abort("String must contain some digits.")

s = upper_(s)

s = s[2..-1]

if (s == "") Fiber.abort("String after base specifier must contain some digits.")

return (neg) ? -res : res

}

// Convenience versions of itoa and atoi which use a base of 10.

static itoa(s) { itoa(s, 10) }

static atoi(s) { atoi(s, 10) }

// Integer/bool conversion routines.

static itob(i) { (i is Num && i.isInteger) ? (i != 0) : null }

static btoi(b) { (b is Bool) ? (b ? 1 : 0) : null }

// Integer/character conversion routines.

static itoc(i) { (i is Num && i.isInteger && i >= 0 && i <= 0x10ffff) ? String.fromCodePoint(i) : null }

static ctoi(c) { (c is String && c.count == 1) ? c.codePoints[0] : null }

static bin(n) { itoa(n, 2) } // Converts an integer to binary.

static oct(n) { itoa(n, 8) } // Converts an integer to octal.

static dec(n) { itoa(n, 10) } // Ensures safe decimal integers printed as such.

static hex(n) { itoa(n, 16) } // Converts an integer to hex.

static Hex(n) { Conv.Itoa(n, 16) } // Converts an integer to hex (upper case digits).

static pdec(n) { ((n >= 0) ? "+" : "") + dec(n) } // Adds '+' for non-negative integers.

static mdec(n) { ((n >= 0) ? " " : "") + dec(n) } // Only uses '-', leaves space for '+'.

static ord(n) {

if (!(n is Num && n.isInteger && n >= 0)) Fiber.abort("Argument must be a non-negative integer.")

return "%(n)%(suffix)"

}

}

/* Fmt contains routines which format numbers or strings in various ways. */

class Fmt {

return (w > c) ? s + p * (w - c) : s

}

// Right justifies 's' in a field of minimum width 'w' using the pad character 'p'.

static rjust(w, s, p) {

return (w > c) ? p * (w - c) + s : s

}

// Centers 's' in a field of minimum width 'w' using the pad character 'p'.

static cjust(w, s, p) {

return p * l + s + p * (w - c - l)

}

// Convenience versions of the above which use a space as the pad character.

static ljust(w, s) { ljust(w, s, " ") }

static rjust(w, s) { rjust(w, s, " ") }

static cjust(w, s) { cjust(w, s, " ") }

// Right justifies 's' in a field of minimum width 'w' using the pad character '0'.

// Unlike rjust, any sign or elided sign (i.e. space) will be placed before the padding.

return sign + "0" * (w - c) + s[1..-1]

}

// Private helper method for 'commatize' method.

// Checks whether argument is a numeric decimal string.

return n.all { |c| "0123456789".contains(c) }

}

// Adds 'thousand separators' to a decimal integer or string.

static commatize(n, c) {

return (signed) ? sign + n : n

}

// Convenience version of the above method which uses a comma as the separator.

static commatize(n) { commatize(n, ",") }

// Private helper method for 'abbreviate' method.

static sub_(s, r) { s.toList[r].join() }

// Abbreviates a string 's' to a maximum number of characters 'w' (non-overlapping) at either end

// or, if 'w' is negative from the front only, using 'sep' as the separator.

// Doesn't abbreviate a string unless at least one character would need to be suppressed.

static abbreviate(w, s, sep) {

if (!(sep is String)) Fiber.abort("Separator must be a string.")

if (!(s is String)) s = "%(s)"

return sub_(s, 0...le) + sep + ((w >= 0) ? sub_(s, -le..-1) : "")

}

static precision { ( __precision != null) ? __precision : 6 }

static precision=(p) { __precision = ((p is Num) && p.isInteger && p >= 0) ? p : __precision }

/* 'Short name' methods, useful for formatting values in interpolated strings. */

// Pads with spaces to a minimum width of 'w'.

// Negative 'w' left justifies, non-negative 'w' right justifies.

static d(w, n) { (w >= 0) ? rjust(w, Conv.dec(n)) : ljust(-w, Conv.dec(n)) }

static x(w, n) { (w >= 0) ? rjust(w, Conv.hex(n)) : ljust(-w, Conv.hex(n)) }

static X(w, n) { (w >= 0) ? rjust(w, Conv.Hex(n)) : ljust(-w, Conv.Hex(n)) }

// As above but pads with leading zeros instead of spaces.

// Any minus sign will be placed before the padding.

// When used with negative 'w' behaves the same as the above methods.

static dz(w, n) { (w >= 0) ? zfill(w, Conv.dec(n)) : ljust(-w, Conv.dec(n)) }

static oz(w, n) { (w >= 0) ? zfill(w, Conv.oct(n)) : ljust(-w, Conv.oct(n)) }

static xz(w, n) { (w >= 0) ? zfill(w, Conv.hex(n)) : ljust(-w, Conv.hex(n)) }

static Xz(w, n) { (w >= 0) ? zfill(w, Conv.Hex(n)) : ljust(-w, Conv.Hex(n)) }

// Formats 'n' in decimal, space padded, with a leading '+' if 'n' is non-negative or '-' otherwise.

static dp(w, n) { (w >= 0) ? rjust(w, Conv.pdec(n)) : ljust(-w, Conv.pdec(n)) }

// Formats 'n' in decimal, space padded, with a leading ' ' if 'n' is non-negative or '-' otherwise.

static dm(w, n) { (w >= 0) ? rjust(w, Conv.mdec(n)) : ljust(-w, Conv.mdec(n)) }

static dc(w, n) { (w >= 0) ? rjust(w, commatize(Conv.dec(n))): ljust(-w, commatize(Conv.dec(n))) }

// Pads a string or value 'v' with spaces to a minimum width of 'w'.

// Negative 'w' left justifies, non-negative 'w' right justifies.

 

// Embeds a string or value 'v' in 'cc', a string with no more than two characters.

}

if (len == 0) return (v is String) ? v : "%(v)"

return "%(cc[0])%(v)%(cc[1])"

}

// Convenience version of the above which uses double quotes as the embedding characters.

static q(v) { "\"%(v)\"" }

 

// Pads a number 'n' with leading spaces to a minimum width 'w' and a precision of 'p' decimal places.

var d = (n - i).abs

var pw = 10.pow(p)

if (d >= pw) {

ns = "%(Conv.dec(n.round))"

d = 0

if (d == 0) return s(w, ns + "." + "0" * p)

var ds = "%(d)"

 

// Works like 'f' except replaces any trailing zeros after the decimal point with spaces.

static g(w, n, p) {

var f = f(w, n, p)

var l1 = f.count

if (f[-1] == ".") f = f + "0"

f = f + (" " * (l1 - f.count))

return f

}

 

// As above but pads with leading zeros instead of spaces.

static fz(w, n, p) { (w >= 0) ? zfill(w, f(w, n, p).trimStart()) : f(w, n, p) }

static gz(w, n, p) { (w >= 0) ? zfill(w, g(w, n, p).trimStart()) : g(w, n, p) }

 

// Formats the integer part of 'n' in commatized form, space padded,

static gc(w, n, p) {

var f = fc(w, n, p)

var l1 = f.count

if (f[-1] == ".") f = f + "0"

f = f + (" " * (l1 - f.count))

}

return f

}

 

// Convenience versions of the above methods which use the default precision.

 

// Applies a 'short' formatting method to each element of a list or sequence 'seq'.

// The method to be applied is specified (as a string) in 'fn'.

// The parameters to be passed to the method are specified in 'w' and 'p'

// The resulting strings are then joined together using the separator 'sep'.

// having first applied the 'q' method, with parameter 'cc', to each of them.

static v(fn, w, seq, p, sep, bb, cc) {

var l = List.filled(seq.count, "")

}

return q(l.join(sep), bb)

// for some parameters.

static v(fn, w, seq, p, sep, bb) { v(fn, w, seq, p, sep, bb, "") }

static v(fn, w, seq, p) { v(fn, w, seq, p, ", ", "[]", "") }

static v(fn, w, seq) { v(fn, w, seq, precision, ", ", "[]", "") }

}