Make Nix builds work

1 files changed, 189 insertions, 0 deletions

diff --git a/vendor/github.com/dustin/go-humanize/bigbytes.go b/vendor/github.com/dustin/go-humanize/bigbytes.go
new file mode 100644
index 0000000..3b015fd
--- /dev/null
+++ b/vendor/github.com/dustin/go-humanize/bigbytes.go
@@ -0,0 +1,189 @@
+package humanize
+
+import (
+        "fmt"
+        "math/big"
+        "strings"
+        "unicode"
+)
+
+var (
+        bigIECExp = big.NewInt(1024)
+
+        // BigByte is one byte in bit.Ints
+        BigByte = big.NewInt(1)
+        // BigKiByte is 1,024 bytes in bit.Ints
+        BigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)
+        // BigMiByte is 1,024 k bytes in bit.Ints
+        BigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)
+        // BigGiByte is 1,024 m bytes in bit.Ints
+        BigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)
+        // BigTiByte is 1,024 g bytes in bit.Ints
+        BigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)
+        // BigPiByte is 1,024 t bytes in bit.Ints
+        BigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)
+        // BigEiByte is 1,024 p bytes in bit.Ints
+        BigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)
+        // BigZiByte is 1,024 e bytes in bit.Ints
+        BigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)
+        // BigYiByte is 1,024 z bytes in bit.Ints
+        BigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)
+        // BigRiByte is 1,024 y bytes in bit.Ints
+        BigRiByte = (&big.Int{}).Mul(BigYiByte, bigIECExp)
+        // BigQiByte is 1,024 r bytes in bit.Ints
+        BigQiByte = (&big.Int{}).Mul(BigRiByte, bigIECExp)
+)
+
+var (
+        bigSIExp = big.NewInt(1000)
+
+        // BigSIByte is one SI byte in big.Ints
+        BigSIByte = big.NewInt(1)
+        // BigKByte is 1,000 SI bytes in big.Ints
+        BigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)
+        // BigMByte is 1,000 SI k bytes in big.Ints
+        BigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)
+        // BigGByte is 1,000 SI m bytes in big.Ints
+        BigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)
+        // BigTByte is 1,000 SI g bytes in big.Ints
+        BigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)
+        // BigPByte is 1,000 SI t bytes in big.Ints
+        BigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)
+        // BigEByte is 1,000 SI p bytes in big.Ints
+        BigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)
+        // BigZByte is 1,000 SI e bytes in big.Ints
+        BigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)
+        // BigYByte is 1,000 SI z bytes in big.Ints
+        BigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)
+        // BigRByte is 1,000 SI y bytes in big.Ints
+        BigRByte = (&big.Int{}).Mul(BigYByte, bigSIExp)
+        // BigQByte is 1,000 SI r bytes in big.Ints
+        BigQByte = (&big.Int{}).Mul(BigRByte, bigSIExp)
+)
+
+var bigBytesSizeTable = map[string]*big.Int{
+        "b":   BigByte,
+        "kib": BigKiByte,
+        "kb":  BigKByte,
+        "mib": BigMiByte,
+        "mb":  BigMByte,
+        "gib": BigGiByte,
+        "gb":  BigGByte,
+        "tib": BigTiByte,
+        "tb":  BigTByte,
+        "pib": BigPiByte,
+        "pb":  BigPByte,
+        "eib": BigEiByte,
+        "eb":  BigEByte,
+        "zib": BigZiByte,
+        "zb":  BigZByte,
+        "yib": BigYiByte,
+        "yb":  BigYByte,
+        "rib": BigRiByte,
+        "rb":  BigRByte,
+        "qib": BigQiByte,
+        "qb":  BigQByte,
+        // Without suffix
+        "":   BigByte,
+        "ki": BigKiByte,
+        "k":  BigKByte,
+        "mi": BigMiByte,
+        "m":  BigMByte,
+        "gi": BigGiByte,
+        "g":  BigGByte,
+        "ti": BigTiByte,
+        "t":  BigTByte,
+        "pi": BigPiByte,
+        "p":  BigPByte,
+        "ei": BigEiByte,
+        "e":  BigEByte,
+        "z":  BigZByte,
+        "zi": BigZiByte,
+        "y":  BigYByte,
+        "yi": BigYiByte,
+        "r":  BigRByte,
+        "ri": BigRiByte,
+        "q":  BigQByte,
+        "qi": BigQiByte,
+}
+
+var ten = big.NewInt(10)
+
+func humanateBigBytes(s, base *big.Int, sizes []string) string {
+        if s.Cmp(ten) < 0 {
+                return fmt.Sprintf("%d B", s)
+        }
+        c := (&big.Int{}).Set(s)
+        val, mag := oomm(c, base, len(sizes)-1)
+        suffix := sizes[mag]
+        f := "%.0f %s"
+        if val < 10 {
+                f = "%.1f %s"
+        }
+
+        return fmt.Sprintf(f, val, suffix)
+
+}
+
+// BigBytes produces a human readable representation of an SI size.
+//
+// See also: ParseBigBytes.
+//
+// BigBytes(82854982) -> 83 MB
+func BigBytes(s *big.Int) string {
+        sizes := []string{"B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "RB", "QB"}
+        return humanateBigBytes(s, bigSIExp, sizes)
+}
+
+// BigIBytes produces a human readable representation of an IEC size.
+//
+// See also: ParseBigBytes.
+//
+// BigIBytes(82854982) -> 79 MiB
+func BigIBytes(s *big.Int) string {
+        sizes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB", "RiB", "QiB"}
+        return humanateBigBytes(s, bigIECExp, sizes)
+}
+
+// ParseBigBytes parses a string representation of bytes into the number
+// of bytes it represents.
+//
+// See also: BigBytes, BigIBytes.
+//
+// ParseBigBytes("42 MB") -> 42000000, nil
+// ParseBigBytes("42 mib") -> 44040192, nil
+func ParseBigBytes(s string) (*big.Int, error) {
+        lastDigit := 0
+        hasComma := false
+        for _, r := range s {
+                if !(unicode.IsDigit(r) || r == '.' || r == ',') {
+                        break
+                }
+                if r == ',' {
+                        hasComma = true
+                }
+                lastDigit++
+        }
+
+        num := s[:lastDigit]
+        if hasComma {
+                num = strings.Replace(num, ",", "", -1)
+        }
+
+        val := &big.Rat{}
+        _, err := fmt.Sscanf(num, "%f", val)
+        if err != nil {
+                return nil, err
+        }
+
+        extra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))
+        if m, ok := bigBytesSizeTable[extra]; ok {
+                mv := (&big.Rat{}).SetInt(m)
+                val.Mul(val, mv)
+                rv := &big.Int{}
+                rv.Div(val.Num(), val.Denom())
+                return rv, nil
+        }
+
+        return nil, fmt.Errorf("unhandled size name: %v", extra)
+}