Drover's back, baby!

go/src/infra/libs/gitiles/object.go

+package gitiles
+
+import "fmt"
+import "net/http"
+import "strings"
+
+import "infra/libs/git"
+
+// ObjectResult is the error/git.{Blob|Commit|Tree} result you get back in
+// a channel from GetBlobFromPath
+type ObjectResult struct {
+        Err    error
+        Object git.InternableObject
+}
+
+// GetObjectFromPath returns a channel yielding an ObjectResult from this Gitiles
+// service.  This will hit the url:
+//   {g.url}/+/{committish}/path/pieces...?format=TEXT
+// Passing NO pieces will return a git.Commit
+// Passing A blank piece (e.g. empty string) will return a git.Tree for the root
+//   tree.
+// Passing non-blank pieces will return a git.Tree or git.Blob depending on
+//   the path.
+func (g *Gitiles) GetObjectFromPath(committish string, pathPieces ...string) <-chan ObjectResult {
+        ret := make(chan ObjectResult, 1)
+        g.requests <- objRequest{
+                textRequest{
+                        strings.Join(append([]string{"+", committish}, pathPieces...), "/"),
+                        nil,
+                },
+                ret,
+        }
+        return ret
+}
+
+// Private
+
+type objRequest struct {
+        textRequest
+        resultChan chan<- ObjectResult
+}
+
+func (o objRequest) Process(rsp *http.Response, err error) {
+        var rslt ObjectResult
+
+        data, err := o.internalProcess(rsp, err)
+        if err != nil {
+                rslt.Err = err
+        } else {
+                typ := rsp.Header.Get("X-Gitiles-Object-Type")
+                switch typ {
+                case "blob":
+                        rslt.Object = git.BlobFromRaw(data)
+                case "tree":
+                        // TODO(riannucci): When gitiles supports format=RAW, use that instead
+                        if tree, err := git.TreeFromText(data); err != nil {
+                                rslt.Err = err
+                        } else {
+                                rslt.Object = tree
+                        }
+                case "commit":
+                        if c, err := git.CommitFromRaw(data); err != nil {
+                                rslt.Err = err
+                        } else {
+                                rslt.Object = c
+                        }
+                default:
+                        rslt.Err = fmt.Errorf("Unknown object type %#v", typ)
+                }
+        }
+
+        o.resultChan <- rslt
+}