Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Improve coverage & Report. Version bump
- Loading branch information
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,64 @@ | ||
| /* ----------------------------------------------------------------- | ||
| * L o r d O f S c r i p t s (tm) | ||
| * Copyright (C)2024 Dídimo Grimaldo T. | ||
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||
| * | ||
| *-----------------------------------------------------------------*/ | ||
| package wipechromium | ||
|
|
||
| import ( | ||
| "fmt" | ||
| ) | ||
|
|
||
| /* ---------------------------------------------------------------- | ||
| * F u n c t i o n s | ||
| *-----------------------------------------------------------------*/ | ||
|
|
||
| // Byte count formatted using International System (1K = 1000) | ||
| func ByteCountSI(b int64) string { | ||
| const UNIT = 1000 | ||
| if b < UNIT { | ||
| return fmt.Sprintf("%d B", b) | ||
| } | ||
| div, exp := int64(UNIT), 0 | ||
| for n := b / UNIT; n >= UNIT; n /= UNIT { | ||
| div *= UNIT | ||
| exp++ | ||
| } | ||
| return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "kMGTPE"[exp]) | ||
| } | ||
|
|
||
| // Byte count formatted using IEC (Binary) system (1K = 1024) | ||
| func ByteCountIEC(b int64) string { | ||
| const UNIT = 1024 | ||
| if b < UNIT { | ||
| return fmt.Sprintf("%d B", b) | ||
| } | ||
| div, exp := int64(UNIT), 0 | ||
| for n := b / UNIT; n >= UNIT; n /= UNIT { | ||
| div *= UNIT | ||
| exp++ | ||
| } | ||
| return fmt.Sprintf("%.1f %ciB", float64(b)/float64(div), "KMGTPE"[exp]) | ||
| } | ||
|
|
||
| func AddThousands(nr int64, sep rune) string { | ||
| var result string = "" | ||
| nrS := Reverse(fmt.Sprintf("%d", nr)) | ||
|
|
||
| for start := 0; start < len(nrS); start += 3 { | ||
| if start+3 < len(nrS) { | ||
| group := nrS[start : start+3] | ||
| if start != 0 { | ||
| result = result + string(sep) + group | ||
| } else { | ||
| result = group | ||
| } | ||
| } else { | ||
| group := nrS[start:] | ||
| result = result + string(sep) + group | ||
| break | ||
| } | ||
| } | ||
| return Reverse(result) | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,212 @@ | ||
| /* ----------------------------------------------------------------- | ||
| * L o r d O f S c r i p t s (tm) | ||
| * Copyright (C)2024 Dídimo Grimaldo T. | ||
| * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||
| * | ||
| *-----------------------------------------------------------------*/ | ||
| package wipechromium | ||
|
|
||
| /* | ||
| Author: https://github.com/gorhill | ||
| Source: https://gist.github.com/gorhill/5285193 | ||
| A Go function to render a number to a string based on | ||
| the following user-specified criteria: | ||
| * thousands separator | ||
| * decimal separator | ||
| * decimal precision | ||
| Usage: s := RenderFloat(format, n) | ||
| The format parameter tells how to render the number n. | ||
| http://play.golang.org/p/LXc1Ddm1lJ | ||
| Examples of format strings, given n = 12345.6789: | ||
| "#,###.##" => "12,345.67" | ||
| "#,###." => "12,345" | ||
| "#,###" => "12345,678" | ||
| "#\u202F###,##" => "12 345,67" | ||
| "#.###,###### => 12.345,678900 | ||
| "" (aka default format) => 12,345.67 | ||
| The highest precision allowed is 9 digits after the decimal symbol. | ||
| There is also a version for integer number, RenderInteger(), | ||
| which is convenient for calls within template. | ||
| I didn't feel it was worth to publish a library just for this piece | ||
| of code, hence the snippet. Feel free to reuse as you wish. | ||
| */ | ||
|
|
||
| import ( | ||
| "math" | ||
| "strconv" | ||
| ) | ||
|
|
||
| /* ---------------------------------------------------------------- | ||
| * G l o b a l s | ||
| *-----------------------------------------------------------------*/ | ||
|
|
||
| var renderFloatPrecisionMultipliers = [10]float64{ | ||
| 1, | ||
| 10, | ||
| 100, | ||
| 1000, | ||
| 10000, | ||
| 100000, | ||
| 1000000, | ||
| 10000000, | ||
| 100000000, | ||
| 1000000000, | ||
| } | ||
|
|
||
| var renderFloatPrecisionRounders = [10]float64{ | ||
| 0.5, | ||
| 0.05, | ||
| 0.005, | ||
| 0.0005, | ||
| 0.00005, | ||
| 0.000005, | ||
| 0.0000005, | ||
| 0.00000005, | ||
| 0.000000005, | ||
| 0.0000000005, | ||
| } | ||
|
|
||
| /* ---------------------------------------------------------------- | ||
| * F u n c t i o n s | ||
| *-----------------------------------------------------------------*/ | ||
|
|
||
| func RenderFloat(format string, n float64) string { | ||
| // Special cases: | ||
| // NaN = "NaN" | ||
| // +Inf = "+Infinity" | ||
| // -Inf = "-Infinity" | ||
| if math.IsNaN(n) { | ||
| return "NaN" | ||
| } | ||
| if n > math.MaxFloat64 { | ||
| return "Infinity" | ||
| } | ||
| if n < -math.MaxFloat64 { | ||
| return "-Infinity" | ||
| } | ||
|
|
||
| // default format | ||
| precision := 2 | ||
| decimalStr := "." | ||
| thousandStr := "," | ||
| positiveStr := "" | ||
| negativeStr := "-" | ||
|
|
||
| if len(format) > 0 { | ||
| // If there is an explicit format directive, | ||
| // then default values are these: | ||
| precision = 9 | ||
| thousandStr = "" | ||
|
|
||
| // collect indices of meaningful formatting directives | ||
| formatDirectiveChars := []rune(format) | ||
| formatDirectiveIndices := make([]int, 0) | ||
| for i, char := range formatDirectiveChars { | ||
| if char != '#' && char != '0' { | ||
| formatDirectiveIndices = append(formatDirectiveIndices, i) | ||
| } | ||
| } | ||
|
|
||
| if len(formatDirectiveIndices) > 0 { | ||
| // Directive at index 0: | ||
| // Must be a '+' | ||
| // Raise an error if not the case | ||
| // index: 0123456789 | ||
| // +0.000,000 | ||
| // +000,000.0 | ||
| // +0000.00 | ||
| // +0000 | ||
| if formatDirectiveIndices[0] == 0 { | ||
| if formatDirectiveChars[formatDirectiveIndices[0]] != '+' { | ||
| panic("RenderFloat(): invalid positive sign directive") | ||
| } | ||
| positiveStr = "+" | ||
| formatDirectiveIndices = formatDirectiveIndices[1:] | ||
| } | ||
|
|
||
| // Two directives: | ||
| // First is thousands separator | ||
| // Raise an error if not followed by 3-digit | ||
| // 0123456789 | ||
| // 0.000,000 | ||
| // 000,000.00 | ||
| if len(formatDirectiveIndices) == 2 { | ||
| if (formatDirectiveIndices[1] - formatDirectiveIndices[0]) != 4 { | ||
| panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers") | ||
| } | ||
| thousandStr = string(formatDirectiveChars[formatDirectiveIndices[0]]) | ||
| formatDirectiveIndices = formatDirectiveIndices[1:] | ||
| } | ||
|
|
||
| // One directive: | ||
| // Directive is decimal separator | ||
| // The number of digit-specifier following the separator indicates wanted precision | ||
| // 0123456789 | ||
| // 0.00 | ||
| // 000,0000 | ||
| if len(formatDirectiveIndices) == 1 { | ||
| decimalStr = string(formatDirectiveChars[formatDirectiveIndices[0]]) | ||
| precision = len(formatDirectiveChars) - formatDirectiveIndices[0] - 1 | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // generate sign part | ||
| var signStr string | ||
| if n >= 0.000000001 { | ||
| signStr = positiveStr | ||
| } else if n <= -0.000000001 { | ||
| signStr = negativeStr | ||
| n = -n | ||
| } else { | ||
| signStr = "" | ||
| n = 0.0 | ||
| } | ||
|
|
||
| // split number into integer and fractional parts | ||
| intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision]) | ||
|
|
||
| // generate integer part string | ||
| //intStr := strconv.Itoa(int(intf)) | ||
| // On a Raspberry Pi which runs a 32-bit version of Raspbian Linux | ||
| // (even though it has a 64-bit CPU) using go version go1.14.2 linux/arm, | ||
| // John Taylor had to change this line. Otherwise RenderInteger("#,###.", n) | ||
| // would fail when n > 2^32. | ||
| intStr := strconv.FormatInt(int64(intf), 10) | ||
|
|
||
| // add thousand separator if required | ||
| if len(thousandStr) > 0 { | ||
| for i := len(intStr); i > 3; { | ||
| i -= 3 | ||
| intStr = intStr[:i] + thousandStr + intStr[i:] | ||
| } | ||
| } | ||
|
|
||
| // no fractional part, we can leave now | ||
| if precision == 0 { | ||
| return signStr + intStr | ||
| } | ||
|
|
||
| // generate fractional part | ||
| fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision])) | ||
| // may need padding | ||
| if len(fracStr) < precision { | ||
| fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr | ||
| } | ||
|
|
||
| return signStr + intStr + decimalStr + fracStr | ||
| } | ||
|
|
||
| func RenderInteger(format string, n int) string { | ||
| return RenderFloat(format, float64(n)) | ||
| } |
Oops, something went wrong.