refactor(unixfs/pb) mv proto PBData -> Data, etc.

fuse/ipns/ipns_unix.go

@@ -207,11 +207,11 @@ type Node struct {
 	Ipfs   *core.IpfsNode
 	Nd     *mdag.Node
 	dagMod *uio.DagModifier
-	cached *ftpb.PBData
+	cached *ftpb.Data
 }
 
 func (s *Node) loadData() error {
-	s.cached = new(ftpb.PBData)
+	s.cached = new(ftpb.Data)
 	return proto.Unmarshal(s.Nd.Data, s.cached)
 }
 
@@ -224,9 +224,9 @@ func (s *Node) Attr() fuse.Attr {
 		}
 	}
 	switch s.cached.GetType() {
-	case ftpb.PBData_Directory:
+	case ftpb.Data_Directory:
 		return fuse.Attr{Mode: os.ModeDir | 0555}
-	case ftpb.PBData_File, ftpb.PBData_Raw:
+	case ftpb.Data_File, ftpb.Data_Raw:
 		size, err := ft.DataSize(s.Nd.Data)
 		if err != nil {
 			log.Error("Error getting size of file: %s", err)

fuse/readonly/readonly_unix.go

@@ -81,11 +81,11 @@ type Node struct {
 	Ipfs   *core.IpfsNode
 	Nd     *mdag.Node
 	fd     *uio.DagReader
-	cached *ftpb.PBData
+	cached *ftpb.Data
 }
 
 func (s *Node) loadData() error {
-	s.cached = new(ftpb.PBData)
+	s.cached = new(ftpb.Data)
 	return proto.Unmarshal(s.Nd.Data, s.cached)
 }
 
@@ -96,9 +96,9 @@ func (s *Node) Attr() fuse.Attr {
 		s.loadData()
 	}
 	switch s.cached.GetType() {
-	case ftpb.PBData_Directory:
+	case ftpb.Data_Directory:
 		return fuse.Attr{Mode: os.ModeDir | 0555}
-	case ftpb.PBData_File, ftpb.PBData_Raw:
+	case ftpb.Data_File, ftpb.Data_Raw:
 		size, _ := s.Nd.Size()
 		return fuse.Attr{
 			Mode:   0444,

unixfs/format.go

@@ -13,8 +13,8 @@ var ErrMalformedFileFormat = errors.New("malformed data in file format")
 var ErrInvalidDirLocation = errors.New("found directory node in unexpected place")
 var ErrUnrecognizedType = errors.New("unrecognized node type")
 
-func FromBytes(data []byte) (*pb.PBData, error) {
-	pbdata := new(pb.PBData)
+func FromBytes(data []byte) (*pb.Data, error) {
+	pbdata := new(pb.Data)
 	err := proto.Unmarshal(data, pbdata)
 	if err != nil {
 		return nil, err
@@ -23,8 +23,8 @@ func FromBytes(data []byte) (*pb.PBData, error) {
 }
 
 func FilePBData(data []byte, totalsize uint64) []byte {
-	pbfile := new(pb.PBData)
-	typ := pb.PBData_File
+	pbfile := new(pb.Data)
+	typ := pb.Data_File
 	pbfile.Type = &typ
 	pbfile.Data = data
 	pbfile.Filesize = proto.Uint64(totalsize)
@@ -43,8 +43,8 @@ func FilePBData(data []byte, totalsize uint64) []byte {
 
 // Returns Bytes that represent a Directory
 func FolderPBData() []byte {
-	pbfile := new(pb.PBData)
-	typ := pb.PBData_Directory
+	pbfile := new(pb.Data)
+	typ := pb.Data_Directory
 	pbfile.Type = &typ
 
 	data, err := proto.Marshal(pbfile)
@@ -56,8 +56,8 @@ func FolderPBData() []byte {
 }
 
 func WrapData(b []byte) []byte {
-	pbdata := new(pb.PBData)
-	typ := pb.PBData_Raw
+	pbdata := new(pb.Data)
+	typ := pb.Data_Raw
 	pbdata.Data = b
 	pbdata.Type = &typ
 
@@ -71,7 +71,7 @@ func WrapData(b []byte) []byte {
 }
 
 func UnwrapData(data []byte) ([]byte, error) {
-	pbdata := new(pb.PBData)
+	pbdata := new(pb.Data)
 	err := proto.Unmarshal(data, pbdata)
 	if err != nil {
 		return nil, err
@@ -80,18 +80,18 @@ func UnwrapData(data []byte) ([]byte, error) {
 }
 
 func DataSize(data []byte) (uint64, error) {
-	pbdata := new(pb.PBData)
+	pbdata := new(pb.Data)
 	err := proto.Unmarshal(data, pbdata)
 	if err != nil {
 		return 0, err
 	}
 
 	switch pbdata.GetType() {
-	case pb.PBData_Directory:
+	case pb.Data_Directory:
 		return 0, errors.New("Cant get data size of directory!")
-	case pb.PBData_File:
+	case pb.Data_File:
 		return pbdata.GetFilesize(), nil
-	case pb.PBData_Raw:
+	case pb.Data_Raw:
 		return uint64(len(pbdata.GetData())), nil
 	default:
 		return 0, errors.New("Unrecognized node data type!")
@@ -110,8 +110,8 @@ func (mb *MultiBlock) AddBlockSize(s uint64) {
 }
 
 func (mb *MultiBlock) GetBytes() ([]byte, error) {
-	pbn := new(pb.PBData)
-	t := pb.PBData_File
+	pbn := new(pb.Data)
+	t := pb.Data_File
 	pbn.Type = &t
 	pbn.Filesize = proto.Uint64(uint64(len(mb.Data)) + mb.subtotal)
 	pbn.Blocksizes = mb.blocksizes

unixfs/format_test.go

@@ -20,7 +20,7 @@ func TestMultiBlock(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	pbn := new(pb.PBData)
+	pbn := new(pb.Data)
 	err = proto.Unmarshal(b, pbn)
 	if err != nil {
 		t.Fatal(err)

unixfs/io/dagmodifier.go

@@ -20,7 +20,7 @@ type DagModifier struct {
 	dagserv *mdag.DAGService
 	curNode *mdag.Node
 
-	pbdata   *ftpb.PBData
+	pbdata   *ftpb.Data
 	splitter chunk.BlockSplitter
 }
 

unixfs/io/dagreader.go

@@ -25,23 +25,23 @@ type DagReader struct {
 // NewDagReader creates a new reader object that reads the data represented by the given
 // node, using the passed in DAGService for data retreival
 func NewDagReader(n *mdag.Node, serv *mdag.DAGService) (io.Reader, error) {
-	pb := new(ftpb.PBData)
+	pb := new(ftpb.Data)
 	err := proto.Unmarshal(n.Data, pb)
 	if err != nil {
 		return nil, err
 	}
 
 	switch pb.GetType() {
-	case ftpb.PBData_Directory:
+	case ftpb.Data_Directory:
 		// Dont allow reading directories
 		return nil, ErrIsDir
-	case ftpb.PBData_File:
+	case ftpb.Data_File:
 		return &DagReader{
 			node: n,
 			serv: serv,
 			buf:  bytes.NewBuffer(pb.GetData()),
 		}, nil
-	case ftpb.PBData_Raw:
+	case ftpb.Data_Raw:
 		// Raw block will just be a single level, return a byte buffer
 		return bytes.NewBuffer(pb.GetData()), nil
 	default:
@@ -64,7 +64,7 @@ func (dr *DagReader) precalcNextBuf() error {
 		}
 		nxt = nxtNode
 	}
-	pb := new(ftpb.PBData)
+	pb := new(ftpb.Data)
 	err := proto.Unmarshal(nxt.Data, pb)
 	if err != nil {
 		return err
@@ -72,13 +72,13 @@ func (dr *DagReader) precalcNextBuf() error {
 	dr.position++
 
 	switch pb.GetType() {
-	case ftpb.PBData_Directory:
+	case ftpb.Data_Directory:
 		return ft.ErrInvalidDirLocation
-	case ftpb.PBData_File:
+	case ftpb.Data_File:
 		//TODO: this *should* work, needs testing first
 		//return NewDagReader(nxt, dr.serv)
 		panic("Not yet handling different layers of indirection!")
-	case ftpb.PBData_Raw:
+	case ftpb.Data_Raw:
 		dr.buf = bytes.NewBuffer(pb.GetData())
 		return nil
 	default:

unixfs/pb/unixfs.pb.go

@@ -9,7 +9,7 @@ It is generated from these files:
 	unixfs.proto
 
 It has these top-level messages:
-	PBData
+	Data
 */
 package unixfs_pb
 
@@ -20,76 +20,76 @@ import math "math"
 var _ = proto.Marshal
 var _ = math.Inf
 
-type PBData_DataType int32
+type Data_DataType int32
 
 const (
-	PBData_Raw       PBData_DataType = 0
-	PBData_Directory PBData_DataType = 1
-	PBData_File      PBData_DataType = 2
+	Data_Raw       Data_DataType = 0
+	Data_Directory Data_DataType = 1
+	Data_File      Data_DataType = 2
 )
 
-var PBData_DataType_name = map[int32]string{
+var Data_DataType_name = map[int32]string{
 	0: "Raw",
 	1: "Directory",
 	2: "File",
 }
-var PBData_DataType_value = map[string]int32{
+var Data_DataType_value = map[string]int32{
 	"Raw":       0,
 	"Directory": 1,
 	"File":      2,
 }
 
-func (x PBData_DataType) Enum() *PBData_DataType {
-	p := new(PBData_DataType)
+func (x Data_DataType) Enum() *Data_DataType {
+	p := new(Data_DataType)
 	*p = x
 	return p
 }
-func (x PBData_DataType) String() string {
-	return proto.EnumName(PBData_DataType_name, int32(x))
+func (x Data_DataType) String() string {
+	return proto.EnumName(Data_DataType_name, int32(x))
 }
-func (x *PBData_DataType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(PBData_DataType_value, data, "PBData_DataType")
+func (x *Data_DataType) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Data_DataType_value, data, "Data_DataType")
 	if err != nil {
 		return err
 	}
-	*x = PBData_DataType(value)
+	*x = Data_DataType(value)
 	return nil
 }
 
-type PBData struct {
-	Type             *PBData_DataType `protobuf:"varint,1,req,enum=unixfs.pb.PBData_DataType" json:"Type,omitempty"`
-	Data             []byte           `protobuf:"bytes,2,opt" json:"Data,omitempty"`
-	Filesize         *uint64          `protobuf:"varint,3,opt,name=filesize" json:"filesize,omitempty"`
-	Blocksizes       []uint64         `protobuf:"varint,4,rep,name=blocksizes" json:"blocksizes,omitempty"`
-	XXX_unrecognized []byte           `json:"-"`
+type Data struct {
+	Type             *Data_DataType `protobuf:"varint,1,req,enum=unixfs.pb.Data_DataType" json:"Type,omitempty"`
+	Data             []byte         `protobuf:"bytes,2,opt" json:"Data,omitempty"`
+	Filesize         *uint64        `protobuf:"varint,3,opt,name=filesize" json:"filesize,omitempty"`
+	Blocksizes       []uint64       `protobuf:"varint,4,rep,name=blocksizes" json:"blocksizes,omitempty"`
+	XXX_unrecognized []byte         `json:"-"`
 }
 
-func (m *PBData) Reset()         { *m = PBData{} }
-func (m *PBData) String() string { return proto.CompactTextString(m) }
-func (*PBData) ProtoMessage()    {}
+func (m *Data) Reset()         { *m = Data{} }
+func (m *Data) String() string { return proto.CompactTextString(m) }
+func (*Data) ProtoMessage()    {}
 
-func (m *PBData) GetType() PBData_DataType {
+func (m *Data) GetType() Data_DataType {
 	if m != nil && m.Type != nil {
 		return *m.Type
 	}
-	return PBData_Raw
+	return Data_Raw
 }
 
-func (m *PBData) GetData() []byte {
+func (m *Data) GetData() []byte {
 	if m != nil {
 		return m.Data
 	}
 	return nil
 }
 
-func (m *PBData) GetFilesize() uint64 {
+func (m *Data) GetFilesize() uint64 {
 	if m != nil && m.Filesize != nil {
 		return *m.Filesize
 	}
 	return 0
 }
 
-func (m *PBData) GetBlocksizes() []uint64 {
+func (m *Data) GetBlocksizes() []uint64 {
 	if m != nil {
 		return m.Blocksizes
 	}
@@ -97,5 +97,5 @@ func (m *PBData) GetBlocksizes() []uint64 {
 }
 
 func init() {
-	proto.RegisterEnum("unixfs.pb.PBData_DataType", PBData_DataType_name, PBData_DataType_value)
+	proto.RegisterEnum("unixfs.pb.Data_DataType", Data_DataType_name, Data_DataType_value)
 }

unixfs/pb/unixfs.proto

 package unixfs.pb;
 
-message PBData {
+message Data {
 	enum DataType {
 		Raw = 0;
 		Directory = 1;