Changed bytes to gytes

Signed-off-by: Vishal Rana <[email protected]>

Author: vishr

bytes/README.md

@@ -0,0 +1,37 @@
+# Gytes
+
+Format bytes to string
+
+## Installation
+
+```go
+go get github.com/labstack/gommon/gytes
+```
+
+## [Usage](https://github.com/labstack/gommon/blob/master/gytes/gytes_test.go)
+
+```sh
+import github.com/labstack/gommon/gytes
+```
+
+### Decimal prefix
+
+```go
+fmt.Println(gytes.Format(1323))
+```
+
+`1.32 KB`
+
+### Binary prefix
+
+```go
+gytes.BinaryPrefix(true)
+fmt.Println(gytes.Format(1323))
+```
+
+`1.29 KiB`
+
+Above examples operate on global instance of Gytes. To create a new instance
+
+```go
+

bytes/bytes.go

@@ -0,0 +1,60 @@
+package bytes
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+var (
+	global = New()
+)
+
+type (
+	Gytes struct {
+		iec bool
+	}
+)
+
+func New() *Gytes {
+	return &Gytes{}
+}
+
+// BinaryPrefix turns on binary prefix format.
+func (g *Gytes) BinaryPrefix(on bool) {
+	g.iec = on
+}
+
+// Format formats bytes to string. For example, 1323 bytes will return 1.32 KB.
+// If binary prefix is set, it will return 1.29 KiB.
+func (g *Gytes) Format(b uint64) string {
+	unit := uint64(1000)
+	if g.iec {
+		unit = 1024
+	}
+	if b < unit {
+		return strconv.FormatUint(b, 10) + " B"
+	} else {
+		b := float64(b)
+		unit := float64(unit)
+		x := math.Floor(math.Log(b) / math.Log(unit))
+		pre := make([]byte, 1, 2)
+		pre[0] = "KMGTPE"[uint8(x)-1]
+		if g.iec {
+			pre = pre[:2]
+			pre[1] = 'i'
+		}
+		// TODO: Improve performance?
+		return fmt.Sprintf("%.02f %sB", b/math.Pow(unit, x), pre)
+	}
+}
+
+// BinaryPrefix wraps default instance's BinaryPrefix function.
+func BinaryPrefix(on bool) {
+	global.BinaryPrefix(on)
+}
+
+// Format wraps default instance's Format function.
+func Format(b uint64) string {
+	return global.Format(b)
+}

bytes/bytes_test.go

@@ -0,0 +1,47 @@
+package bytes
+
+import "testing"
+
+func TestGytes(t *testing.T) {
+	// B
+	b := Format(515)
+	if b != "515 B" {
+		t.Errorf("expected `515 B`, got %s", b)
+	}
+
+	// MB
+	b = Format(13231323)
+	if b != "13.23 MB" {
+		t.Errorf("expected `13.23 MB`, got %s", b)
+	}
+
+	// Exact
+	b = Format(1000 * 1000 * 1000)
+	if b != "1.00 GB" {
+		t.Errorf("expected `1.00 GB`, got %s", b)
+	}
+
+	// Binary prefix
+	BinaryPrefix(true)
+	b = Format(1323)
+	if b != "1.29 KiB" {
+		t.Errorf("expected `1.29 KiB`, got %s", b)
+	}
+}
+
+func TestNew(t *testing.T) {
+	g := New()
+
+	b := g.Format(132313231323)
+	if b != "132.31 GB" {
+		t.Errorf("expected `132.31 GB`, got %s", b)
+	}
+
+	// Binary prefix
+	g.BinaryPrefix(true)
+	b = Format(1323132313231323)
+	if b != "1.18 PiB" {
+		t.Errorf("expected `1.18 PiB`, got %s", b)
+	}
+}
+