gx publish 0.8.0

Extract non-core functionality from go-cid into go-cidutil

.gx/lastpubver

@@ -1 +1 @@
-0.7.22: QmYVNvtQkeZ6AKSwDrjQTs432QtL6umrrK41EBq3cu7iSP
+0.8.0: QmZFbDTY9jfSBms2MchvYM9oYRbAF19K7Pby47yDBfpPrb

builder.go

@@ -0,0 +1,74 @@
+package cid
+
+import (
+	mh "github.com/multiformats/go-multihash"
+)
+
+type Builder interface {
+	Sum(data []byte) (*Cid, error)
+	GetCodec() uint64
+	WithCodec(uint64) Builder
+}
+
+type V0Builder struct{}
+
+type V1Builder struct {
+	Codec    uint64
+	MhType   uint64
+	MhLength int // MhLength <= 0 means the default length
+}
+
+func (p Prefix) GetCodec() uint64 {
+	return p.Codec
+}
+
+func (p Prefix) WithCodec(c uint64) Builder {
+	if c == p.Codec {
+		return p
+	}
+	p.Codec = c
+	if c != DagProtobuf {
+		p.Version = 1
+	}
+	return p
+}
+
+func (p V0Builder) Sum(data []byte) (*Cid, error) {
+	hash, err := mh.Sum(data, mh.SHA2_256, -1)
+	if err != nil {
+		return nil, err
+	}
+	return NewCidV0(hash), nil
+}
+
+func (p V0Builder) GetCodec() uint64 {
+	return DagProtobuf
+}
+
+func (p V0Builder) WithCodec(c uint64) Builder {
+	if c == DagProtobuf {
+		return p
+	}
+	return V1Builder{Codec: c, MhType: mh.SHA2_256}
+}
+
+func (p V1Builder) Sum(data []byte) (*Cid, error) {
+	mhLen := p.MhLength
+	if mhLen <= 0 {
+		mhLen = -1
+	}
+	hash, err := mh.Sum(data, p.MhType, mhLen)
+	if err != nil {
+		return nil, err
+	}
+	return NewCidV1(p.Codec, hash), nil
+}
+
+func (p V1Builder) GetCodec() uint64 {
+	return p.Codec
+}
+
+func (p V1Builder) WithCodec(c uint64) Builder {
+	p.Codec = c
+	return p
+}

builder_test.go

@@ -0,0 +1,92 @@
+package cid
+
+import (
+	"testing"
+
+	mh "github.com/multiformats/go-multihash"
+)
+
+func TestV0Builder(t *testing.T) {
+	data := []byte("this is some test content")
+
+	// Construct c1
+	format := V0Builder{}
+	c1, err := format.Sum(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Construct c2
+	hash, err := mh.Sum(data, mh.SHA2_256, -1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c2 := NewCidV0(hash)
+
+	if !c1.Equals(c2) {
+		t.Fatal("cids mismatch")
+	}
+	if c1.Prefix() != c2.Prefix() {
+		t.Fatal("prefixes mismatch")
+	}
+}
+
+func TestV1Builder(t *testing.T) {
+	data := []byte("this is some test content")
+
+	// Construct c1
+	format := V1Builder{Codec: DagCBOR, MhType: mh.SHA2_256}
+	c1, err := format.Sum(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Construct c2
+	hash, err := mh.Sum(data, mh.SHA2_256, -1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	c2 := NewCidV1(DagCBOR, hash)
+
+	if !c1.Equals(c2) {
+		t.Fatal("cids mismatch")
+	}
+	if c1.Prefix() != c2.Prefix() {
+		t.Fatal("prefixes mismatch")
+	}
+}
+
+func TestCodecChange(t *testing.T) {
+	t.Run("Prefix-CidV0", func(t *testing.T) {
+		p := Prefix{Version: 0, Codec: DagProtobuf, MhType: mh.SHA2_256, MhLength: mh.DefaultLengths[mh.SHA2_256]}
+		testCodecChange(t, p)
+	})
+	t.Run("Prefix-CidV1", func(t *testing.T) {
+		p := Prefix{Version: 1, Codec: DagProtobuf, MhType: mh.SHA2_256, MhLength: mh.DefaultLengths[mh.SHA2_256]}
+		testCodecChange(t, p)
+	})
+	t.Run("V0Builder", func(t *testing.T) {
+		testCodecChange(t, V0Builder{})
+	})
+	t.Run("V1Builder", func(t *testing.T) {
+		testCodecChange(t, V1Builder{Codec: DagProtobuf, MhType: mh.SHA2_256})
+	})
+}
+
+func testCodecChange(t *testing.T, b Builder) {
+	data := []byte("this is some test content")
+
+	if b.GetCodec() != DagProtobuf {
+		t.Fatal("original builder not using Protobuf codec")
+	}
+
+	b = b.WithCodec(Raw)
+	c, err := b.Sum(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if c.Type() != Raw {
+		t.Fatal("new cid codec did not change to Raw")
+	}
+}

cid-fmt/main.go

@@ -1,277 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"strings"
-
-	c "github.com/ipfs/go-cid"
-
-	mb "github.com/multiformats/go-multibase"
-	mh "github.com/multiformats/go-multihash"
-)
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: %s [-b multibase-code] [-v cid-version] <fmt-str> <cid> ...\n\n", os.Args[0])
-	fmt.Fprintf(os.Stderr, "<fmt-str> is either 'prefix' or a printf style format string:\n%s", fmtRef)
-	os.Exit(2)
-}
-
-const fmtRef = `
-   %% literal %
-   %b multibase name 
-   %B multibase code
-   %v version string
-   %V version number
-   %c codec name
-   %C codec code
-   %h multihash name
-   %H multihash code
-   %L hash digest length
-   %m multihash encoded in base %b (with multibase prefix)
-   %M multihash encoded in base %b without multibase prefix
-   %d hash digest encoded in base %b (with multibase prefix)
-   %D hash digest encoded in base %b without multibase prefix
-   %s cid string encoded in base %b (1)
-   %s cid string encoded in base %b without multibase prefix
-   %P cid prefix: %v-%c-%h-%L
-
-(1) For CID version 0 the multibase must be base58btc and no prefix is
-used.  For Cid version 1 the multibase prefix is included.
-`
-
-func main() {
-	if len(os.Args) < 2 {
-		usage()
-	}
-	newBase := mb.Encoding(-1)
-	var verConv func(cid *c.Cid) (*c.Cid, error)
-	args := os.Args[1:]
-outer:
-	for {
-		switch args[0] {
-		case "-b":
-			if len(args) < 2 {
-				usage()
-			}
-			if len(args[1]) != 1 {
-				fmt.Fprintf(os.Stderr, "Error: Invalid multibase code: %s\n", args[1])
-				os.Exit(2)
-			}
-			newBase = mb.Encoding(args[1][0])
-			args = args[2:]
-		case "-v":
-			if len(args) < 2 {
-				usage()
-			}
-			switch args[1] {
-			case "0":
-				verConv = toCidV0
-			case "1":
-				verConv = toCidV1
-			default:
-				fmt.Fprintf(os.Stderr, "Error: Invalid cid version: %s\n", args[1])
-				os.Exit(2)
-			}
-			args = args[2:]
-		default:
-			break outer
-		}
-	}
-	if len(args) < 2 {
-		usage()
-	}
-	fmtStr := args[0]
-	switch fmtStr {
-	case "prefix":
-		fmtStr = "%P"
-	default:
-		if strings.IndexByte(fmtStr, '%') == -1 {
-			fmt.Fprintf(os.Stderr, "Error: Invalid format string: %s\n", fmtStr)
-			os.Exit(2)
-		}
-	}
-	for _, cidStr := range args[1:] {
-		base, cid, err := decode(cidStr)
-		if err != nil {
-			fmt.Fprintf(os.Stdout, "!INVALID_CID!\n")
-			errorMsg("%s: %v", cidStr, err)
-			// Don't abort on a bad cid
-			continue
-		}
-		if newBase != -1 {
-			base = newBase
-		}
-		if verConv != nil {
-			cid, err = verConv(cid)
-			if err != nil {
-				fmt.Fprintf(os.Stdout, "!ERROR!\n")
-				errorMsg("%s: %v", cidStr, err)
-				// Don't abort on a bad conversion
-				continue
-			}
-		}
-		str, err := fmtCid(fmtStr, base, cid)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			// An error here means a bad format string, no point in continuing
-			os.Exit(2)
-		}
-		fmt.Fprintf(os.Stdout, "%s\n", str)
-	}
-	os.Exit(exitCode)
-}
-
-var exitCode = 0
-
-func errorMsg(fmtStr string, a ...interface{}) {
-	fmt.Fprintf(os.Stderr, "Error: ")
-	fmt.Fprintf(os.Stderr, fmtStr, a...)
-	fmt.Fprintf(os.Stderr, "\n")
-	exitCode = 1
-}
-
-func decode(v string) (mb.Encoding, *c.Cid, error) {
-	if len(v) < 2 {
-		return 0, nil, c.ErrCidTooShort
-	}
-
-	if len(v) == 46 && v[:2] == "Qm" {
-		hash, err := mh.FromB58String(v)
-		if err != nil {
-			return 0, nil, err
-		}
-
-		return mb.Base58BTC, c.NewCidV0(hash), nil
-	}
-
-	base, data, err := mb.Decode(v)
-	if err != nil {
-		return 0, nil, err
-	}
-
-	cid, err := c.Cast(data)
-
-	return base, cid, err
-}
-
-const ERR_STR = "!ERROR!"
-
-func fmtCid(fmtStr string, base mb.Encoding, cid *c.Cid) (string, error) {
-	p := cid.Prefix()
-	out := new(bytes.Buffer)
-	var err error
-	for i := 0; i < len(fmtStr); i++ {
-		if fmtStr[i] != '%' {
-			out.WriteByte(fmtStr[i])
-			continue
-		}
-		i++
-		if i >= len(fmtStr) {
-			return "", fmt.Errorf("premature end of format string")
-		}
-		switch fmtStr[i] {
-		case '%':
-			out.WriteByte('%')
-		case 'b': // base name
-			out.WriteString(baseToString(base))
-		case 'B': // base code
-			out.WriteByte(byte(base))
-		case 'v': // version string
-			fmt.Fprintf(out, "cidv%d", p.Version)
-		case 'V': // version num
-			fmt.Fprintf(out, "%d", p.Version)
-		case 'c': // codec name
-			out.WriteString(codecToString(p.Codec))
-		case 'C': // codec code
-			fmt.Fprintf(out, "%d", p.Codec)
-		case 'h': // hash fun name
-			out.WriteString(hashToString(p.MhType))
-		case 'H': // hash fun code
-			fmt.Fprintf(out, "%d", p.MhType)
-		case 'L': // hash length
-			fmt.Fprintf(out, "%d", p.MhLength)
-		case 'm', 'M': // multihash encoded in base %b
-			out.WriteString(encode(base, cid.Hash(), fmtStr[i] == 'M'))
-		case 'd', 'D': // hash digest encoded in base %b
-			dec, err := mh.Decode(cid.Hash())
-			if err != nil {
-				out.WriteString(ERR_STR)
-				errorMsg("%v", err)
-				continue
-			}
-			out.WriteString(encode(base, dec.Digest, fmtStr[i] == 'D'))
-		case 's': // cid string encoded in base %b
-			str, err := cid.StringOfBase(base)
-			if err != nil {
-				out.WriteString(ERR_STR)
-				errorMsg("%v", err)
-				continue
-			}
-			out.WriteString(str)
-		case 'S': // cid string without base prefix
-			out.WriteString(encode(base, cid.Bytes(), true))
-		case 'P': // prefix
-			fmt.Fprintf(out, "cidv%d-%s-%s-%d",
-				p.Version,
-				codecToString(p.Codec),
-				hashToString(p.MhType),
-				p.MhLength,
-			)
-		default:
-			return "", fmt.Errorf("unrecognized specifier in format string: %c", fmtStr[i])
-		}
-
-	}
-	return out.String(), err
-}
-
-func baseToString(base mb.Encoding) string {
-	// FIXME: Use lookup tables when they are added to go-multibase
-	switch base {
-	case mb.Base58BTC:
-		return "base58btc"
-	default:
-		return fmt.Sprintf("base?%c", base)
-	}
-}
-
-func codecToString(num uint64) string {
-	name, ok := c.CodecToStr[num]
-	if !ok {
-		return fmt.Sprintf("codec?%d", num)
-	}
-	return name
-}
-
-func hashToString(num uint64) string {
-	name, ok := mh.Codes[num]
-	if !ok {
-		return fmt.Sprintf("hash?%d", num)
-	}
-	return name
-}
-
-func encode(base mb.Encoding, data []byte, strip bool) string {
-	str, err := mb.Encode(base, data)
-	if err != nil {
-		errorMsg("%v", err)
-		return ERR_STR
-	}
-	if strip {
-		return str[1:]
-	}
-	return str
-}
-
-func toCidV0(cid *c.Cid) (*c.Cid, error) {
-	if cid.Type() != c.DagProtobuf {
-		return nil, fmt.Errorf("can't convert non-protobuf nodes to cidv0")
-	}
-	return c.NewCidV0(cid.Hash()), nil
-}
-
-func toCidV1(cid *c.Cid) (*c.Cid, error) {
-	return c.NewCidV1(cid.Type(), cid.Hash()), nil
-}

cid-fmt/main_test.go

@@ -1,109 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"testing"
-
-	mb "github.com/multiformats/go-multibase"
-)
-
-func TestFmt(t *testing.T) {
-	cids := map[string]string{
-		"cidv0": "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn",
-		"cidv1": "zdj7WfLr9DhLrb1hsoSi4fSdjjxuZmeqgEtBPWxMLtPbDNbFD",
-	}
-	tests := []struct {
-		cidId   string
-		newBase mb.Encoding
-		fmtStr  string
-		result  string
-	}{
-		{"cidv0", -1, "%P", "cidv0-protobuf-sha2-256-32"},
-		{"cidv0", -1, "%b-%v-%c-%h-%L", "base58btc-cidv0-protobuf-sha2-256-32"},
-		{"cidv0", -1, "%s", "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"},
-		{"cidv0", -1, "%S", "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"},
-		{"cidv0", -1, "ver#%V/#%C/#%H/%L", "ver#0/#112/#18/32"},
-		{"cidv0", -1, "%m", "zQmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"},
-		{"cidv0", -1, "%M", "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"},
-		{"cidv0", -1, "%d", "z72gdmFAgRzYHkJzKiL8MgMMRW3BTSCGyDHroPxJbxMJn"},
-		{"cidv0", -1, "%D", "72gdmFAgRzYHkJzKiL8MgMMRW3BTSCGyDHroPxJbxMJn"},
-		{"cidv0", 'B', "%S", "CIQFTFEEHEDF6KLBT32BFAGLXEZL4UWFNWM4LFTLMXQBCERZ6CMLX3Y"},
-		{"cidv0", 'B', "%B%S", "BCIQFTFEEHEDF6KLBT32BFAGLXEZL4UWFNWM4LFTLMXQBCERZ6CMLX3Y"},
-		{"cidv1", -1, "%P", "cidv1-protobuf-sha2-256-32"},
-		{"cidv1", -1, "%b-%v-%c-%h-%L", "base58btc-cidv1-protobuf-sha2-256-32"},
-		{"cidv1", -1, "%s", "zdj7WfLr9DhLrb1hsoSi4fSdjjxuZmeqgEtBPWxMLtPbDNbFD"},
-		{"cidv1", -1, "%S", "dj7WfLr9DhLrb1hsoSi4fSdjjxuZmeqgEtBPWxMLtPbDNbFD"},
-		{"cidv1", -1, "ver#%V/#%C/#%H/%L", "ver#1/#112/#18/32"},
-		{"cidv1", -1, "%m", "zQmYFbmndVP7QqAVWyKhpmMuQHMaD88pkK57RgYVimmoh5H"},
-		{"cidv1", -1, "%M", "QmYFbmndVP7QqAVWyKhpmMuQHMaD88pkK57RgYVimmoh5H"},
-		{"cidv1", -1, "%d", "zAux4gVVsLRMXtsZ9fd3tFEZN4jGYB6kP37fgoZNTc11H"},
-		{"cidv1", -1, "%D", "Aux4gVVsLRMXtsZ9fd3tFEZN4jGYB6kP37fgoZNTc11H"},
-		{"cidv1", 'B', "%s", "BAFYBEIETJGSRL3EQPQPCABV3G6IUBYTSIFVQ24XRRHD3JUETSKLTGQ7DJA"},
-		{"cidv1", 'B', "%S", "AFYBEIETJGSRL3EQPQPCABV3G6IUBYTSIFVQ24XRRHD3JUETSKLTGQ7DJA"},
-		{"cidv1", 'B', "%B%S", "BAFYBEIETJGSRL3EQPQPCABV3G6IUBYTSIFVQ24XRRHD3JUETSKLTGQ7DJA"},
-	}
-	for _, tc := range tests {
-		name := fmt.Sprintf("%s/%s", tc.cidId, tc.fmtStr)
-		if tc.newBase != -1 {
-			name = fmt.Sprintf("%s/%c", name, tc.newBase)
-		}
-		cidStr := cids[tc.cidId]
-		t.Run(name, func(t *testing.T) {
-			testFmt(t, cidStr, tc.newBase, tc.fmtStr, tc.result)
-		})
-	}
-}
-
-func testFmt(t *testing.T, cidStr string, newBase mb.Encoding, fmtStr string, result string) {
-	base, cid, err := decode(cidStr)
-	if newBase != -1 {
-		base = newBase
-	}
-	if err != nil {
-		t.Fatal(err)
-	}
-	str, err := fmtCid(fmtStr, base, cid)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if str != result {
-		t.Error(fmt.Sprintf("expected: %s; but got: %s", result, str))
-	}
-}
-
-func TestCidConv(t *testing.T) {
-	cidv0 := "QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn"
-	cidv1 := "zdj7WbTaiJT1fgatdet9Ei9iDB5hdCxkbVyhyh8YTUnXMiwYi"
-	_, cid, err := decode(cidv0)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cid, err = toCidV1(cid)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cid.String() != cidv1 {
-		t.Fatal("conversion failure")
-	}
-	cid, err = toCidV0(cid)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cidStr := cid.String()
-	if cidStr != cidv0 {
-		t.Error(fmt.Sprintf("conversion failure, expected: %s; but got: %s", cidv0, cidStr))
-	}
-}
-
-func TestBadCidConv(t *testing.T) {
-	// this cid is a raw leaf and should not be able to convert to cidv0
-	cidv1 := "zb2rhhzX7uSKrtQ2ZZXFAabKiKFYZrJqKY2KE1cJ8yre2GSWZ"
-	_, cid, err := decode(cidv1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cid, err = toCidV0(cid)
-	if err == nil {
-		t.Fatal("expected failure")
-	}
-}

cid.go

@@ -77,6 +77,8 @@ const (
 	BitcoinTx          = 0xb1
 	ZcashBlock         = 0xc0
 	ZcashTx            = 0xc1
+	DecredBlock        = 0xe0
+	DecredTx           = 0xe1
 )
 
 // Codecs maps the name of a codec to its type
@@ -99,6 +101,8 @@ var Codecs = map[string]uint64{
 	"bitcoin-tx":           BitcoinTx,
 	"zcash-block":          ZcashBlock,
 	"zcash-tx":             ZcashTx,
+	"decred-block":         DecredBlock,
+	"decred-tx":            DecredTx,
 }
 
 // CodecToStr maps the numeric codec to its name
@@ -120,6 +124,8 @@ var CodecToStr = map[uint64]string{
 	BitcoinTx:          "bitcoin-tx",
 	ZcashBlock:         "zcash-block",
 	ZcashTx:            "zcash-tx",
+	DecredBlock:        "decred-block",
+	DecredTx:           "decred-tx",
 }
 
 // NewCidV0 returns a Cid-wrapped multihash.
@@ -144,27 +150,6 @@ func NewCidV1(codecType uint64, mhash mh.Multihash) *Cid {
 	}
 }
 
-// NewPrefixV0 returns a CIDv0 prefix with the specified multihash type.
-func NewPrefixV0(mhType uint64) Prefix {
-	return Prefix{
-		MhType:   mhType,
-		MhLength: mh.DefaultLengths[mhType],
-		Version:  0,
-		Codec:    DagProtobuf,
-	}
-}
-
-// NewPrefixV1 returns a CIDv1 prefix with the specified codec and multihash
-// type.
-func NewPrefixV1(codecType uint64, mhType uint64) Prefix {
-	return Prefix{
-		MhType:   mhType,
-		MhLength: mh.DefaultLengths[mhType],
-		Version:  1,
-		Codec:    codecType,
-	}
-}
-
 // Cid represents a self-describing content adressed
 // identifier. It is formed by a Version, a Codec (which indicates
 // a multicodec-packed content type) and a Multihash.
@@ -228,6 +213,28 @@ func Decode(v string) (*Cid, error) {
 	return Cast(data)
 }
 
+// Extract the encoding from a Cid.  If Decode on the same string did
+// not return an error neither will this function.
+func ExtractEncoding(v string) (mbase.Encoding, error) {
+	if len(v) < 2 {
+		return -1, ErrCidTooShort
+	}
+
+	if len(v) == 46 && v[:2] == "Qm" {
+		return mbase.Base58BTC, nil
+	}
+
+	encoding := mbase.Encoding(v[0])
+
+	// check encoding is valid
+	_, err := mbase.NewEncoder(encoding)
+	if err != nil {
+		return -1, err
+	}
+
+	return encoding, nil
+}
+
 func uvError(read int) error {
 	switch {
 	case read == 0:
@@ -442,6 +449,8 @@ func (c *Cid) Prefix() Prefix {
 // that is, the Version, the Codec, the Multihash type
 // and the Multihash length. It does not contains
 // any actual content information.
+// NOTE: The use -1 in MhLength to mean default length is deprecated,
+//   use the V0Builder or V1Builder structures instead
 type Prefix struct {
 	Version  uint64
 	Codec    uint64

cid_test.go

@@ -33,6 +33,8 @@ var tCodecs = map[uint64]string{
 	BitcoinTx:          "bitcoin-tx",
 	ZcashBlock:         "zcash-block",
 	ZcashTx:            "zcash-tx",
+	DecredBlock:        "decred-block",
+	DecredTx:           "decred-tx",
 }
 
 func assertEqual(t *testing.T, a, b *Cid) {
@@ -412,3 +414,17 @@ func TestJsonRoundTrip(t *testing.T) {
 		t.Fatal("cids not equal for Cid")
 	}
 }
+
+func BenchmarkStringV1(b *testing.B) {
+	data := []byte("this is some test content")
+	hash, _ := mh.Sum(data, mh.SHA2_256, -1)
+	cid := NewCidV1(Raw, hash)
+	b.ResetTimer()
+	count := 0
+	for i := 0; i < b.N; i++ {
+		count += len(cid.String())
+	}
+	if count != 49*b.N {
+		b.FailNow()
+	}
+}

deprecated.go

@@ -0,0 +1,28 @@
+package cid
+
+import (
+	mh "github.com/multiformats/go-multihash"
+)
+
+// NewPrefixV0 returns a CIDv0 prefix with the specified multihash type.
+// DEPRECATED: Use V0Builder
+func NewPrefixV0(mhType uint64) Prefix {
+	return Prefix{
+		MhType:   mhType,
+		MhLength: mh.DefaultLengths[mhType],
+		Version:  0,
+		Codec:    DagProtobuf,
+	}
+}
+
+// NewPrefixV1 returns a CIDv1 prefix with the specified codec and multihash
+// type.
+// DEPRECATED: Use V1Builder
+func NewPrefixV1(codecType uint64, mhType uint64) Prefix {
+	return Prefix{
+		MhType:   mhType,
+		MhLength: mh.DefaultLengths[mhType],
+		Version:  1,
+		Codec:    codecType,
+	}
+}

package.json

@@ -15,9 +15,9 @@
     },
     {
       "author": "whyrusleeping",
-      "hash": "QmexBtiTTEwwn42Yi6ouKt6VqzpA6wjJgiW1oh9VfaRrup",
+      "hash": "QmSbvata2WqNkqGtZNg8MR3SKwnB8iQ7vTPJgWqB8bC5kR",
       "name": "go-multibase",
-      "version": "0.2.6"
+      "version": "0.2.7"
     }
   ],
   "gxVersion": "0.8.0",
@@ -25,6 +25,6 @@
   "license": "MIT",
   "name": "go-cid",
   "releaseCmd": "git commit -a -m \"gx publish $VERSION\"",
-  "version": "0.7.22"
+  "version": "0.8.0"
 }
 

set.go

@@ -65,3 +65,4 @@ func (s *Set) ForEach(f func(c *Cid) error) error {
 	}
 	return nil
 }
+

set_test.go

@@ -0,0 +1,92 @@
+package cid
+
+import (
+	"crypto/rand"
+	"errors"
+	"testing"
+
+	mh "github.com/multiformats/go-multihash"
+)
+
+func makeRandomCid(t *testing.T) *Cid {
+	p := make([]byte, 256)
+	_, err := rand.Read(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	h, err := mh.Sum(p, mh.SHA3, 4)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cid := &Cid{
+		codec:   7,
+		version: 1,
+		hash:    h,
+	}
+
+	return cid
+}
+
+func TestSet(t *testing.T) {
+	cid := makeRandomCid(t)
+	cid2 := makeRandomCid(t)
+	s := NewSet()
+
+	s.Add(cid)
+
+	if !s.Has(cid) {
+		t.Error("should have the CID")
+	}
+
+	if s.Len() != 1 {
+		t.Error("should report 1 element")
+	}
+
+	keys := s.Keys()
+
+	if len(keys) != 1 || !keys[0].Equals(cid) {
+		t.Error("key should correspond to Cid")
+	}
+
+	if s.Visit(cid) {
+		t.Error("visit should return false")
+	}
+
+	foreach := []*Cid{}
+	foreachF := func(c *Cid) error {
+		foreach = append(foreach, c)
+		return nil
+	}
+
+	if err := s.ForEach(foreachF); err != nil {
+		t.Error(err)
+	}
+
+	if len(foreach) != 1 {
+		t.Error("ForEach should have visited 1 element")
+	}
+
+	foreachErr := func(c *Cid) error {
+		return errors.New("test")
+	}
+
+	if err := s.ForEach(foreachErr); err == nil {
+		t.Error("Should have returned an error")
+	}
+
+	if !s.Visit(cid2) {
+		t.Error("should have visited a new Cid")
+	}
+
+	if s.Len() != 2 {
+		t.Error("len should be 2 now")
+	}
+
+	s.Remove(cid2)
+
+	if s.Len() != 1 {
+		t.Error("len should be 1 now")
+	}
+}