package git import ( "errors" "fmt" "io" "os" "syscall" "time" "gopkg.in/src-d/go-git.v4/plumbing" "gopkg.in/src-d/go-git.v4/plumbing/format/index" "gopkg.in/src-d/go-git.v4/plumbing/object" "srcd.works/go-billy.v1" ) var ErrWorktreeNotClean = errors.New("worktree is not clean") type Worktree struct { r *Repository fs billy.Filesystem } func (w *Worktree) Checkout(commit plumbing.Hash) error { s, err := w.Status() if err != nil { return err } if !s.IsClean() { return ErrWorktreeNotClean } c, err := w.r.Commit(commit) if err != nil { return err } files, err := c.Files() if err != nil { return err } idx := &index.Index{Version: 2} if err := files.ForEach(func(f *object.File) error { return w.checkoutFile(f, idx) }); err != nil { return err } return w.r.s.SetIndex(idx) } func (w *Worktree) checkoutFile(f *object.File, idx *index.Index) error { from, err := f.Reader() if err != nil { return err } defer from.Close() to, err := w.fs.OpenFile(f.Name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode.Perm()) if err != nil { return err } if _, err := io.Copy(to, from); err != nil { return err } defer to.Close() return w.indexFile(f, idx) } func (w *Worktree) indexFile(f *object.File, idx *index.Index) error { fi, err := w.fs.Stat(f.Name) if err != nil { return err } e := index.Entry{ Hash: f.Hash, Name: f.Name, Mode: fi.Mode(), ModifiedAt: fi.ModTime(), Size: uint32(fi.Size()), } // if the FileInfo.Sys() comes from os the ctime, dev, inode, uid and gid // can be retrieved, otherwise this doesn't apply os, ok := fi.Sys().(*syscall.Stat_t) if ok { e.CreatedAt = time.Unix(int64(os.Ctim.Sec), int64(os.Ctim.Nsec)) e.Dev = uint32(os.Dev) e.Inode = uint32(os.Ino) e.GID = os.Gid e.UID = os.Uid } idx.Entries = append(idx.Entries, e) return nil } func (w *Worktree) Status() (Status, error) { idx, err := w.r.s.Index() if err != nil { return nil, err } files, err := readDirAll(w.fs) if err != nil { return nil, err } s := make(Status, 0) for _, e := range idx.Entries { fi, ok := files[e.Name] delete(files, e.Name) if !ok { s.File(e.Name).Worktree = Deleted continue } status, err := w.compareFileWithEntry(fi, &e) if err != nil { return nil, err } s.File(e.Name).Worktree = status } for f := range files { s.File(f).Worktree = Untracked } return s, nil } func (w *Worktree) compareFileWithEntry(fi billy.FileInfo, e *index.Entry) (StatusCode, error) { if fi.Size() != int64(e.Size) { return Modified, nil } if fi.Mode().Perm() != e.Mode.Perm() { return Modified, nil } h, err := calcSHA1(w.fs, e.Name) if h != e.Hash || err != nil { return Modified, err } return Unmodified, nil } // Status current status of a Worktree type Status map[string]*FileStatus func (s Status) File(filename string) *FileStatus { if _, ok := (s)[filename]; !ok { s[filename] = &FileStatus{} } return s[filename] } func (s Status) IsClean() bool { for _, status := range s { if status.Worktree != Unmodified || status.Staging != Unmodified { return false } } return true } func (s Status) String() string { var names []string for name := range s { names = append(names, name) } var output string for _, name := range names { status := s[name] if status.Staging == 0 && status.Worktree == 0 { continue } if status.Staging == Renamed { name = fmt.Sprintf("%s -> %s", name, status.Extra) } output += fmt.Sprintf("%s%s %s\n", status.Staging, status.Worktree, name) } return output } // FileStatus status of a file in the Worktree type FileStatus struct { Staging StatusCode Worktree StatusCode Extra string } // StatusCode status code of a file in the Worktree type StatusCode int8 const ( Unmodified StatusCode = iota Untracked Modified Added Deleted Renamed Copied UpdatedButUnmerged ) func (c StatusCode) String() string { switch c { case Unmodified: return " " case Modified: return "M" case Added: return "A" case Deleted: return "D" case Renamed: return "R" case Copied: return "C" case UpdatedButUnmerged: return "U" case Untracked: return "?" default: return "-" } } func calcSHA1(fs billy.Filesystem, filename string) (plumbing.Hash, error) { file, err := fs.Open(filename) if err != nil { return plumbing.ZeroHash, err } stat, err := fs.Stat(filename) if err != nil { return plumbing.ZeroHash, err } h := plumbing.NewHasher(plumbing.BlobObject, stat.Size()) if _, err := io.Copy(h, file); err != nil { return plumbing.ZeroHash, err } return h.Sum(), nil } func readDirAll(filesystem billy.Filesystem) (map[string]billy.FileInfo, error) { all := make(map[string]billy.FileInfo, 0) return all, doReadDirAll(filesystem, "", all) } func doReadDirAll(fs billy.Filesystem, path string, files map[string]billy.FileInfo) error { if path == ".git" { return nil } l, err := fs.ReadDir(path) if err != nil { return err } for _, info := range l { file := fs.Join(path, info.Name()) if !info.IsDir() { files[file] = info continue } if err := doReadDirAll(fs, file, files); err != nil { return err } } return nil }