Drover's back, baby!

go/src/infra/libs/git/object.go

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+package git
+
+import (
+        "crypto/sha1"
+        "encoding/hex"
+        "fmt"
+)
+
+type ObjectType uint8

[M-A Ruel, 2014/10/21 00:55:54]

If it's exported, it's worth documenting. :)

+
+const (
+        UnknownType ObjectType = iota
+        CommitType
+        BlobType
+        TreeType

[M-A Ruel, 2014/10/21 00:55:54]

Y U NO TAG? Even if you explicitly do not support it, it's worth stating this
explicitly.

[iannucci, 2016/05/23 21:53:42]

Omission, though "tag" doesn't show up in tree objects. I added it anyway, since
trees explicitly scope to just {Commit, Blob, Tree} types, and it could show up
in a cat-file request.

+)
+
+func (o ObjectType) String() string {
+        switch o {
+        case CommitType:
+                return "commit"
+        case BlobType:
+                return "blob"
+        case TreeType:
+                return "tree"
+        default:
+                return "UNKNOWN"

[Vadim Sh., 2014/10/21 15:26:59]

panic too?

+        }
+}
+
+func MakeObjectType(s string) ObjectType {
+        switch s {
+        case "commit":
+                return CommitType
+        case "blob":
+                return BlobType
+        case "tree":
+                return TreeType
+        default:
+                panic(fmt.Errorf("unknown object type %s", s))
+        }
+}
+
+// Object is the barest essence of a git object. It has a Type, and Id, and it
+// can tell you if this instance is 'complete' (does it contain all the data
+// necessary to re-create ID()?).
+//
+// If Complete() is true, you can down-cast this to:
+//   *Tree, *Blob, *Commit
+//
+// If Complete() is false, you can down-cast this to:
+//   *Tree, EmptyObject
+//
+// Note that Tree's are never EmptyObject's.

[agable, 2014/10/21 17:01:35]

nit: apostrophes

+type Object interface {
+        ID() ObjectID
+
+        Type() ObjectType
+
+        // Returns True iff RawString will produce a string which, when hashed,
+        // matches ID()
+        Complete() bool
+}
+
+// ObjectID is a 20-byte git-sha for any Object type.
+type ObjectID struct {

[M-A Ruel, 2014/10/21 00:55:54]

It's fine and shorter to use 
type ObjectID [20] byte

iif you want. I don't mind.

[agable, 2014/10/21 17:01:35]

Was going to say the same thing. Not sure why this is a struct.

[iannucci, 2016/05/23 21:53:42]

Modifiable, and I can't have a type alias whose 'real' type is private to the
package :(

+        raw [20]byte
+}
+
+// The empty ObjectID (all zeros)
+var NoID = ObjectID{}
+
+// MakeObjectIDForData hashes |data| as the git type |typ| (blob, commit, tree),
+// and returns an ObjectID for it.
+func MakeObjectIDForData(typ ObjectType, data []byte) ObjectID {
+        h := sha1.New()
+        h.Write([]byte(fmt.Sprintf("%s %d\x00", typ, len(data))))
+        h.Write(data)
+        return MakeObjectIDRaw(h.Sum(nil))
+}
+
+// MakeObjectIDRaw treats |raw| as a 20-byte Id. panic()'s if len(raw) is not 20
+func MakeObjectIDRaw(raw []byte) (ret ObjectID) {
+        if len(raw) != 20 {
+                panic("MakeObjectIdRaw() must be invoked with a 20 byte string")
+        }
+        copy(ret.raw[:], raw)
+        return

[Vadim Sh., 2014/10/21 15:26:59]

is this 'return' required here?

+}
+
+// MakeObjectID decodes the 40-byte |hexval| into an ObjectID. panic()'s if
+// len(hexval) is not 40, or if it is not valid hexadecimal.
+func MakeObjectID(hexval string) ObjectID {
+        if len(hexval) != 40 {
+                panic("MakeObjectID() must be invoked with a 40 byte hex string")

[M-A Ruel, 2014/10/21 00:55:54]

In general, packages should not panic. It's really painful to handle otherwise,
even for trivial things like this.

[Vadim Sh., 2014/10/21 15:26:59]

IMHO, panic is like assert. If caller doesn't fullfil the contract, it's
caller's fault.

+        }
+        raw, err := hex.DecodeString(hexval)
+        if err != nil {
+                panic(err)
+        }
+        return MakeObjectIDRaw(raw)
+}
+
+func (o ObjectID) String() string {
+        if o != NoID {
+                return hex.EncodeToString(o.raw[:])
+        }
+        return "<NoID>"
+}
+
+// RawString returns a git hash-object compatible (binary) representation
+// of the ObjectID (e.g. suitable for inclusion in a tree object output)
+func (o ObjectID) RawString() string {
+        return string(o.raw[:])
+}
+
+// EmptyObject is a placeholder Object which is not Internable, but can be
+// used to create a Complete() Tree. It can be of type "commit" or "blob".
+// It is never Complete().
+type EmptyObject struct {
+        id  ObjectID
+        typ ObjectType
+}
+
+func (o EmptyObject) ID() ObjectID     { return o.id }
+func (o EmptyObject) Type() ObjectType { return o.typ }
+func (o EmptyObject) Complete() bool   { return false }
+func (o EmptyObject) String() string {
+        return fmt.Sprintf("EmptyObject(%s, %s)", o.ID(), o.Type())
+}
+
+// NewEmptyObject returns an Object of type |typ| with no data. For "tree" types,
+// this returns an empty Tree (which is mutable). All other types are an
+// EmptyObject.
+func NewEmptyObject(typ ObjectType, id ObjectID) Object {
+        switch typ {
+        case BlobType, CommitType:
+                return EmptyObject{id, typ}
+        case TreeType:
+                return NewEmptyTree(id, 0)
+        default:
+                panic("unknown type " + typ.String())
+        }
+}