[FIX] Cleanup code (#16)

* [FIX] Cleanup code
- cleanup code
- fix bytes package

* work around bytes package and tests

* Fix #12

bytes/bytes.go

@@ -7,12 +7,12 @@ import (
 )
 
 type (
-	Bytes struct {
-	}
+	// Bytes struct
+	Bytes struct{}
 )
 
 const (
-	B = 1 << (10 * iota)
+	_ = 1.0 << (10 * iota) // ignore first value by assigning to blank identifier
 	KB
 	MB
 	GB
@@ -22,7 +22,7 @@ const (
 )
 
 var (
-	pattern = regexp.MustCompile(`(?i)^(-?\d+)([KMGTP]B?|B)$`)
+	pattern = regexp.MustCompile(`(?i)^(-?\d+(?:\.\d+)?)([KMGTPE]B?|B?)$`)
 	global  = New()
 )
 
@@ -38,29 +38,31 @@ func (*Bytes) Format(b int64) string {
 	value := float64(b)
 
 	switch {
-	case b < KB:
-		return strconv.FormatInt(b, 10) + "B"
-	case b < MB:
-		value /= KB
-		multiple = "KB"
-	case b < MB:
-		value /= KB
-		multiple = "KB"
-	case b < GB:
-		value /= MB
-		multiple = "MB"
-	case b < TB:
-		value /= GB
-		multiple = "GB"
-	case b < PB:
-		value /= TB
-		multiple = "TB"
-	case b < EB:
+	case b >= EB:
+		value /= EB
+		multiple = "EB"
+	case b >= PB:
 		value /= PB
 		multiple = "PB"
+	case b >= TB:
+		value /= TB
+		multiple = "TB"
+	case b >= GB:
+		value /= GB
+		multiple = "GB"
+	case b >= MB:
+		value /= MB
+		multiple = "MB"
+	case b >= KB:
+		value /= KB
+		multiple = "KB"
+	case b == 0:
+		return "0"
+	default:
+		return strconv.FormatInt(b, 10) + "B"
 	}
 
-	return fmt.Sprintf("%.02f%s", value, multiple)
+	return fmt.Sprintf("%.2f%s", value, multiple)
 }
 
 // Parse parses human readable bytes string to bytes integer.
@@ -72,27 +74,27 @@ func (*Bytes) Parse(value string) (i int64, err error) {
 	}
 	bytesString := parts[1]
 	multiple := parts[2]
-	bytes, err := strconv.ParseInt(bytesString, 10, 64)
+	bytes, err := strconv.ParseFloat(bytesString, 64)
 	if err != nil {
 		return
 	}
 
 	switch multiple {
-	case "B":
-		return bytes * B, nil
+	default:
+		return int64(bytes), nil
 	case "K", "KB":
-		return bytes * KB, nil
+		return int64(bytes * KB), nil
 	case "M", "MB":
-		return bytes * MB, nil
+		return int64(bytes * MB), nil
 	case "G", "GB":
-		return bytes * GB, nil
+		return int64(bytes * GB), nil
 	case "T", "TB":
-		return bytes * TB, nil
+		return int64(bytes * TB), nil
 	case "P", "PB":
-		return bytes * PB, nil
+		return int64(bytes * PB), nil
+	case "E", "EB":
+		return int64(bytes * EB), nil
 	}
-
-	return
 }
 
 // Format wraps global Bytes's Format function.

bytes/bytes_test.go

@@ -1,6 +1,7 @@
 package bytes
 
 import (
+	"math"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -8,7 +9,10 @@ import (
 
 func TestBytesFormat(t *testing.T) {
 	// B
-	b := Format(515)
+	b := Format(0)
+	assert.Equal(t, "0", b)
+	// B
+	b = Format(515)
 	assert.Equal(t, "515B", b)
 
 	// KB
@@ -30,16 +34,63 @@ func TestBytesFormat(t *testing.T) {
 	// PB
 	b = Format(9923232398434432)
 	assert.Equal(t, "8.81PB", b)
+
+	// EB
+	b = Format(math.MaxInt64)
+	assert.Equal(t, "8.00EB", b)
+}
+
+func TestBytesParseErrors(t *testing.T) {
+	_, err := Parse("B999")
+	if assert.Error(t, err) {
+		assert.EqualError(t, err, "error parsing value=B999")
+	}
+}
+
+func TestFloats(t *testing.T) {
+	// From string:
+	str := "12.25KB"
+	value, err := Parse(str)
+	assert.NoError(t, err)
+	assert.Equal(t, int64(12544), value)
+
+	str2 := Format(value)
+	assert.Equal(t, str, str2)
+
+	// To string:
+	val := int64(13233029)
+	str = Format(val)
+	assert.Equal(t, "12.62MB", str)
+
+	val2, err := Parse(str)
+	assert.NoError(t, err)
+	assert.Equal(t, val, val2)
 }
 
 func TestBytesParse(t *testing.T) {
 	// B
-	b, err := Parse("515B")
+	b, err := Parse("999")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(999), b)
+	}
+	b, err = Parse("-100")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(-100), b)
+	}
+	b, err = Parse("100.1")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(100), b)
+	}
+	b, err = Parse("515B")
 	if assert.NoError(t, err) {
 		assert.Equal(t, int64(515), b)
 	}
 
 	// KB
+	b, err = Parse("12.25KB")
+	if assert.NoError(t, err) {
+		assert.Equal(t, int64(12544), b)
+	}
 	b, err = Parse("12KB")
 	if assert.NoError(t, err) {
 		assert.Equal(t, int64(12288), b)
@@ -88,4 +139,14 @@ func TestBytesParse(t *testing.T) {
 	if assert.NoError(t, err) {
 		assert.Equal(t, int64(10133099161583616), b)
 	}
+
+	// EB
+	b, err = Parse("8EB")
+	if assert.NoError(t, err) {
+		assert.True(t, math.MaxInt64 == b-1)
+	}
+	b, err = Parse("8E")
+	if assert.NoError(t, err) {
+		assert.True(t, math.MaxInt64 == b-1)
+	}
 }

email/email.go

@@ -4,11 +4,9 @@ import (
 	"bytes"
 	"crypto/tls"
 	"html/template"
+	"net"
 	"net/mail"
 	"net/smtp"
-
-	"net"
-
 	"time"
 
 	"github.com/labstack/gommon/random"

log/log.go

@@ -8,11 +8,10 @@ import (
 	"os"
 	"path"
 	"runtime"
+	"strconv"
 	"sync"
 	"time"
 
-	"strconv"
-
 	"github.com/mattn/go-isatty"
 	"github.com/valyala/fasttemplate"
 

random/random.go

@@ -13,13 +13,13 @@ type (
 
 // Charsets
 const (
-	Uppercase    string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	Lowercase           = "abcdefghijklmnopqrstuvwxyz"
-	Alphabetic          = Uppercase + Lowercase
-	Numeric             = "0123456789"
-	Alphanumeric        = Alphabetic + Numeric
-	Symbols             = "`" + `~!@#$%^&*()-_+={}[]|\;:"<>,./?`
-	Hex                 = Numeric + "abcdef"
+	Uppercase    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	Lowercase    = "abcdefghijklmnopqrstuvwxyz"
+	Alphabetic   = Uppercase + Lowercase
+	Numeric      = "0123456789"
+	Alphanumeric = Alphabetic + Numeric
+	Symbols      = "`" + `~!@#$%^&*()-_+={}[]|\;:"<>,./?`
+	Hex          = Numeric + "abcdef"
 )
 
 var (