[fmtutil] Code refactoring

Author: andyone

CHANGELOG.md

@@ -13,6 +13,7 @@
 - **`[ease]`** Fixed `SineIn` and `SineOut` calculation
 - **`[ease]`** Fixed overshoot constant for `BackIn`, `BackOut`, and `BackInOut`
 - **`[fmtc]`** Fixed Off-by-One bug in 256-Color range validation
+- **`[fmtutil]`** Method `ParseSize` now returns parsing error
 - **`[timeutil]`** Fixed `%c` output in `Format`
 - **`[timeutil]`** Fixed bug with formatting timezone offset
 - **`[timeutil]`** Fixed ISO week calculation
@@ -27,6 +28,7 @@
 - **`[errors]`** Code refactoring
 - **`[events]`** Code refactoring
 - **`[fmtc]`** Code refactoring
+- **`[fmtutil]`** Code refactoring
 - **`[log]`** Code refactoring
 - **`[req]`** Code refactoring
 

fmtutil/example_test.go

@@ -119,9 +119,14 @@ func ExampleParseSize() {
 	s2 := "34Mb"
 	s3 := "2.2 GB"
 
-	fmt.Printf("%s → %d\n", s1, ParseSize(s1))
-	fmt.Printf("%s → %d\n", s2, ParseSize(s2))
-	fmt.Printf("%s → %d\n", s3, ParseSize(s3))
+	si1, _ := ParseSize(s1)
+	fmt.Printf("%s → %d\n", s1, si1)
+
+	si2, _ := ParseSize(s2)
+	fmt.Printf("%s → %d\n", s2, si2)
+
+	si3, _ := ParseSize(s3)
+	fmt.Printf("%s → %d\n", s3, si3)
 
 	// Output:
 	// 160 → 160

fmtutil/fmtutil.go

@@ -162,28 +162,23 @@ func PrettyBool(b bool, vals ...string) string {
 
 // ParseSize parses a human-readable size string and returns the equivalent byte count
 // (e.g. "2.2 GB" → 2362232012).
-func ParseSize(size string) uint64 {
+func ParseSize(size string) (uint64, error) {
 	v := strings.ToLower(strings.ReplaceAll(size, " ", ""))
 	mod, suf := extractSizeInfo(v)
 
-	if suf == "" {
-		num, err := strconv.ParseUint(size, 10, 64)
-
-		if err != nil {
-			return 0
-		}
+	v = strings.TrimRight(v, suf)
 
-		return num
+	if v == "" {
+		return 0, fmt.Errorf("size has no digits")
 	}
 
-	v = strings.TrimRight(v, suf)
 	numFlt, err := strconv.ParseFloat(v, 64)
 
 	if err != nil {
-		return 0
+		return 0, err
 	}
 
-	return uint64(numFlt * mod)
+	return uint64(numFlt * mod), nil
 }
 
 // Float rounds f to 2 decimal places below 10, or 1 decimal place above. Returns 0.0
@@ -353,8 +348,7 @@ func appendPrettySymbol(str, sep string) string {
 
 // extractSizeInfo returns the byte multiplier and suffix for a size string
 func extractSizeInfo(s string) (float64, string) {
-	var mod float64
-
+	mod := 1.0
 	suf := strings.TrimLeft(s, "0123456789. ")
 
 	switch suf {
@@ -375,7 +369,7 @@ func extractSizeInfo(s string) (float64, string) {
 	case "k":
 		mod = 1000
 	case "b":
-		mod = 1
+		// okay
 	default:
 		suf = ""
 	}

fmtutil/fmtutil_test.go

@@ -92,23 +92,58 @@ func (s *FmtUtilSuite) TestPrettyBool(c *C) {
 }
 
 func (s *FmtUtilSuite) TestParseSize(c *C) {
-	c.Assert(ParseSize("1 MB"), Equals, uint64(1024*1024))
-	c.Assert(ParseSize("1 M"), Equals, uint64(1000*1000))
-	c.Assert(ParseSize("2tb"), Equals, uint64(2*1024*1024*1024*1024))
-	c.Assert(ParseSize("2t"), Equals, uint64(2*1000*1000*1000*1000))
-	c.Assert(ParseSize("5gB"), Equals, uint64(5*1024*1024*1024))
-	c.Assert(ParseSize("5g"), Equals, uint64(5*1000*1000*1000))
-	c.Assert(ParseSize("13kb"), Equals, uint64(13*1024))
-	c.Assert(ParseSize("13k"), Equals, uint64(13*1000))
-	c.Assert(ParseSize("13kk"), Equals, uint64(13*1000*1000))
-	c.Assert(ParseSize("13kkk"), Equals, uint64(13*1000*1000*1000))
-	c.Assert(ParseSize("512"), Equals, uint64(512))
-	c.Assert(ParseSize("kb"), Equals, uint64(0))
-	c.Assert(ParseSize("123!"), Equals, uint64(0))
-
-	c.Assert(ParseSize(PrettySize(345)), Equals, uint64(345))
-	c.Assert(ParseSize(PrettySize(1025)), Equals, uint64(1024))
-	c.Assert(ParseSize(PrettySize(1024*1024)), Equals, uint64(1024*1024))
+	size, err := ParseSize("1 MB")
+	c.Assert(err, IsNil)
+	c.Assert(size, Equals, uint64(1024*1024))
+
+	size, _ = ParseSize("2tb")
+	c.Assert(size, Equals, uint64(2*1024*1024*1024*1024))
+
+	size, _ = ParseSize("5gB")
+	c.Assert(size, Equals, uint64(5*1024*1024*1024))
+
+	size, _ = ParseSize("13kb")
+	c.Assert(size, Equals, uint64(13*1024))
+
+	size, _ = ParseSize("1 M")
+	c.Assert(size, Equals, uint64(1000*1000))
+
+	size, _ = ParseSize("2t")
+	c.Assert(size, Equals, uint64(2*1000*1000*1000*1000))
+
+	size, _ = ParseSize("5g")
+	c.Assert(size, Equals, uint64(5*1000*1000*1000))
+
+	size, _ = ParseSize("13k")
+	c.Assert(size, Equals, uint64(13*1000))
+
+	size, _ = ParseSize("13kk")
+	c.Assert(size, Equals, uint64(13*1000*1000))
+
+	size, _ = ParseSize("13kkk")
+	c.Assert(size, Equals, uint64(13*1000*1000*1000))
+
+	size, _ = ParseSize("512")
+	c.Assert(size, Equals, uint64(512))
+
+	size, _ = ParseSize(PrettySize(345))
+	c.Assert(size, Equals, uint64(345))
+
+	size, _ = ParseSize(PrettySize(1025))
+	c.Assert(size, Equals, uint64(1024))
+
+	size, _ = ParseSize(PrettySize(1024 * 1024))
+	c.Assert(size, Equals, uint64(1024*1024))
+
+	size, err = ParseSize("kb")
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, `size has no digits`)
+	c.Assert(size, Equals, uint64(0))
+
+	size, err = ParseSize("123!")
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, `strconv.ParseFloat: parsing "123!": invalid syntax`)
+	c.Assert(size, Equals, uint64(0))
 }
 
 func (s *FmtUtilSuite) TestFloat(c *C) {