// Encode transforms a Tag into a plumbing.Object.
func (t *Tag) Encode(o plumbing.Object) error {
o.SetType(plumbing.TagObject)
w, err := o.Writer()
if err != nil {
return err
}
defer checkClose(w, &err)
if _, err = fmt.Fprintf(w,
"object %s\ntype %s\ntag %s\ntagger ",
t.Target.String(), t.TargetType.Bytes(), t.Name); err != nil {
return err
}
if err = t.Tagger.Encode(w); err != nil {
return err
}
if _, err = fmt.Fprint(w, "\n\n"); err != nil {
return err
}
if _, err = fmt.Fprint(w, t.Message); err != nil {
return err
}
return err
}
func (d *Decoder) fillRegularObjectContent(obj plumbing.Object) (uint32, error) {
w, err := obj.Writer()
if err != nil {
return 0, err
}
_, crc, err := d.s.NextObject(w)
return crc, err
}
func (d *Decoder) fillOFSDeltaObjectContent(obj plumbing.Object, offset int64) (uint32, error) {
buf := bytes.NewBuffer(nil)
_, crc, err := d.s.NextObject(buf)
if err != nil {
return 0, err
}
base, err := d.recallByOffset(offset)
if err != nil {
return 0, err
}
obj.SetType(base.Type())
return crc, ApplyDelta(obj, base, buf.Bytes())
}
// Encode transforms a Blob into a plumbing.Object.
func (b *Blob) Encode(o plumbing.Object) error {
w, err := o.Writer()
if err != nil {
return err
}
defer checkClose(w, &err)
r, err := b.Reader()
if err != nil {
return err
}
defer checkClose(r, &err)
_, err = io.Copy(w, r)
o.SetType(plumbing.BlobObject)
return err
}
func (iter *ObjectIter) toObject(obj plumbing.Object) (Object, error) {
switch obj.Type() {
case plumbing.BlobObject:
blob := &Blob{}
return blob, blob.Decode(obj)
case plumbing.TreeObject:
tree := &Tree{r: iter.r}
return tree, tree.Decode(obj)
case plumbing.CommitObject:
commit := &Commit{}
return commit, commit.Decode(obj)
case plumbing.TagObject:
tag := &Tag{}
return tag, tag.Decode(obj)
default:
return nil, plumbing.ErrInvalidType
}
}
func (o *ObjectStorage) SetObject(obj plumbing.Object) (plumbing.Hash, error) {
h := obj.Hash()
o.Objects[h] = obj
switch obj.Type() {
case plumbing.CommitObject:
o.Commits[h] = o.Objects[h]
case plumbing.TreeObject:
o.Trees[h] = o.Objects[h]
case plumbing.BlobObject:
o.Blobs[h] = o.Objects[h]
case plumbing.TagObject:
o.Tags[h] = o.Objects[h]
default:
return h, ErrUnsupportedObjectType
}
return h, nil
}
// ApplyDelta writes to taget the result of applying the modification deltas in delta to base.
func ApplyDelta(target, base plumbing.Object, delta []byte) error {
r, err := base.Reader()
if err != nil {
return err
}
w, err := target.Writer()
if err != nil {
return err
}
src, err := ioutil.ReadAll(r)
if err != nil {
return err
}
dst := PatchDelta(src, delta)
target.SetSize(int64(len(dst)))
if _, err := w.Write(dst); err != nil {
return err
}
return nil
}
// Decode transforms a plumbing.Object into a Blob struct.
func (b *Blob) Decode(o plumbing.Object) error {
if o.Type() != plumbing.BlobObject {
return ErrUnsupportedObject
}
b.Hash = o.Hash()
b.Size = o.Size()
b.obj = o
return nil
}
// Decode transforms a plumbing.Object into a Tag struct.
func (t *Tag) Decode(o plumbing.Object) (err error) {
if o.Type() != plumbing.TagObject {
return ErrUnsupportedObject
}
t.Hash = o.Hash()
reader, err := o.Reader()
if err != nil {
return err
}
defer checkClose(reader, &err)
r := bufio.NewReader(reader)
for {
line, err := r.ReadSlice('\n')
if err != nil && err != io.EOF {
return err
}
line = bytes.TrimSpace(line)
if len(line) == 0 {
break // Start of message
}
split := bytes.SplitN(line, []byte{' '}, 2)
switch string(split[0]) {
case "object":
t.Target = plumbing.NewHash(string(split[1]))
case "type":
t.TargetType, err = plumbing.ParseObjectType(string(split[1]))
if err != nil {
return err
}
case "tag":
t.Name = string(split[1])
case "tagger":
t.Tagger.Decode(split[1])
}
if err == io.EOF {
return nil
}
}
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
t.Message = string(data)
return nil
}
func (tx *TxObjectStorage) SetObject(obj plumbing.Object) (plumbing.Hash, error) {
h := obj.Hash()
tx.Objects[h] = obj
return h, nil
}
func (s *Storage) SetObject(obj plumbing.Object) (plumbing.Hash, error) {
key, err := s.buildKey(obj.Hash(), obj.Type())
if err != nil {
return obj.Hash(), err
}
r, err := obj.Reader()
if err != nil {
return obj.Hash(), err
}
c, err := ioutil.ReadAll(r)
if err != nil {
return obj.Hash(), err
}
bins := driver.BinMap{
urlField: s.url,
"hash": obj.Hash().String(),
"type": obj.Type().String(),
"blob": c,
}
err = s.client.Put(nil, key, bins)
return obj.Hash(), err
}
// Set adds a new object to the storage.
func (s *ObjectStorage) SetObject(o plumbing.Object) (plumbing.Hash, error) {
if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
return plumbing.ZeroHash, plumbing.ErrInvalidType
}
ow, err := s.dir.NewObject()
if err != nil {
return plumbing.ZeroHash, err
}
defer ow.Close()
or, err := o.Reader()
if err != nil {
return plumbing.ZeroHash, err
}
defer or.Close()
if err := ow.WriteHeader(o.Type(), o.Size()); err != nil {
return plumbing.ZeroHash, err
}
if _, err := io.Copy(ow, or); err != nil {
return plumbing.ZeroHash, err
}
return o.Hash(), nil
}