Building Git: part VI

2025-06-07

Building Git: Part VI

Git part VI

What’s up everyone, what interesting projects are you guys working on, do tell me. In our previous part we updated our code to make use of add command to store the desired files in the staging area(a.k.a index file), and then update the commit command to commit only those files that are present in our staging area. But there are some problem with our current implementation. That is when we call our add command it overwrites all the files that are already present in the index file and starts from new blank state. This is not helpfull at all, imagine you added some files to the staging area, and after that also edited some other files and then added them to the staging area and commited the staging files. But to your surprise only the files that you added using the second add command that you used. Not good right.

Incremental addition

So in this part we will be updating our add command so that it can add the files to the index or in the staging area. We want to support the incremental update support, i.e. we want to use multiple add commands to update our staging area. And come let’s do that.

Parsing the `.git/index`

Firstly, we will update our handler function to not create a new instance of index but call a function IndexHoldForUpdate that will create a new index instance for us and will load the index file that might be present in the .gitgo directory.

cmd/gitgo/cmdHandler.go

1
func cmdAddHandler(args []string) error {
2
   index := gitgo.NewIndex()
3
   _, index := gitgo.IndexHoldForUpdate()
4
    for _, path := range args {
5
        // ...
6
}

We will update our Index struct to store a new changed flag. It will help us in keep the track we changed the index file has been modified since loading it.

index.go

1
type Index struct {
2
    // ...
3
    changed bool
4
}
5

6
func NewIndex() *Index {
7
    return &Index {
8
        // ...
9
        changed: false,
10
    }
11
}

1
func IndexHoldForUpdate() (bool, *Index) {
2
    index := NewIndex()
3
    b, err := index.lockfile.holdForUpdate()
4
    if err != nil {
5
        return false, nil
6
    }
7
    if !b {
8
        return false, nil
9
    }
10

11
    err = index.Load()
12
    return true, index
13
}

We will get the lock in this function so that we do not have to get the lock for any further calls.

Now we will have to open the index file that might be present in the .gitgo directory.

1
func (i *Index) load() error {
2
    fileReader, err := os.Open(filepath.Join(GITPATH, "index"))
3
    if err != nil {
4
        return err
5
    }
6
    defer fileReader.Close()
7
    hash := new(bytes.Buffer)
8
    count := i.readHeader(fileReader, hash)
9
    i.readEntries(fileReader, count, hash)
10
    verifyChecksum(fileReader, hash)
11

12
    return nil
13
}

First we open the file, create a new hash variable, read the header and get the count of the entries that might be present in the index file and lastly we will verify the checksum.

1
const(
2
    HEADERSIZE   = 12
3
    HEADERFORMAT = "a4N2"
4
    SIGNATURE    = "DIRC"
5
    VERSION      = 2
6
)
7

8

9
func (i *Index) readHeader(f *os.File, h *bytes.Buffer) int {
10
    data, err := read(f, HEADERSIZE)
11
    if err != nil {
12
        log.Fatalf("%s\n", err)
13
    }
14
    signature, version, count := data[:4], data[4:8], data[8:12]
15
    if string(signature) != SIGNATURE {
16
        log.Fatalf("signature: expected %s got %s\n", SIGNATURE, signature)
17
    }
18
    if binary.BigEndian.Uint32(version) != VERSION {
19
        log.Fatalf("version: expected %d got %d\n", binary.BigEndian.Uint32(version), VERSION)
20
    }
21

22
    h.Write(data)
23
    return int(binary.BigEndian.Uint32(count))
24
}

Here we read the file, and then get the signature, version, and count of the entries by splicing the data []byte. We know that signature, version, and count all of these three occupy the 4 byte in the index file. Then we verify that signature and version are what we expect them to be. If they are then we write that data into our []byte slice named hash we created in the load method.

1
func read(f io.Reader, size int, h *bytes.Buffer) ([]byte, error) {
2
    data := make([]byte, size)
3
    _, err := f.Read(data)
4
    if err != nil {
5
        return nil, err
6
    }
7

8
    return data, nil
9
}

Now we will create the readEntries.

1
func (i *Index) readEntries(r io.Reader, count int, h *bytes.Buffer) {
2
    for range count {
3
        entry, err := read(r, ENTRYMINSIZE)
4
        if err != nil {
5
            log.Fatalln(err)
6
        }
7

8
        for entry[len(entry)-1] != byte(0) {
9
            e, err := read(r, ENTRYBLOCK)
10
            if err != nil {
11
                log.Fatalln(err)
12
            }
13

14
            entry = append(entry, e)
15
        }
16

17
        i.storeEntryByte(entry)
18
        _, err := h.Write(entry)
19
        if err != nil {
20
            log.Fatalf("err writing entry to hash: %s\n")
21
        }
22
    }
23
}

First, we read the data for ENTRYMINSIZE count, if we do not find the nil byte in that block, then we again read the next 8 bytes, until we find the nil byte. And store it in our Index and write it in our hash byte slice.

1
func verifyChecksum(f io.Reader, h *bytes.Buffer) {
2
    checksum := make([]byte, 20)
3
    c := bytes.NewBuffer(checksum)
4
    _, err := f.Read(c.AvailableBuffer())
5
    if err != nil {
6
        log.Fatalln(err)
7
    }
8

9
    currChecksum := sha1.Sum(h.Bytes())
10
    currC := bytes.NewBuffer(currChecksum[:])
11

12
    if bytes.Equal(c.Bytes(), currC.Bytes()) {
13
        log.Fatalln("checksums not equal")
14
    }
15
}

You guys can, give better variable name then me, I am just going with the flow. We read the remaining data in the file, that will hopefully only be the SHA1 hash of the index file. We are just checking for the equality here.

Now let’s create the storeEntryByte function that we used in our readEntries function. We read the bytes of the entries and now we want to deserialize them to the IndexEntry struct.

1
func (i *Index) storeEntryByte(entry []byte) {
2
    fNameInEntry := entry[62:]
3
    oidInEntry := entry[40:60]
4
    nullIdx := bytes.IndexByte(fNameInEntry, byte(0))
5

6
    fileName := ""
7
    if nullIdx != -1 {
8
        fileName = string(fNameInEntry[:nullIdx])
9
    } else {
10
        fileName = string(fNameInEntry[:])
11
    }
12

13
    stat, err := os.Stat(fileName)
14
    if err != nil {
15
        log.Fatalln(err)
16
    }
17

18
    i.Add(fileName, hex.EncodeToString(oidInEntry), stat)
19
}

We add them in the Index, and set the changed flag to true.

1
func (i *Index) Add(path, oid string, stat os.FileInfor) {
2
    entry := NewIndexEntry(path, oid, stat)
3
    i.storeEntry(entry)
4
    i.changed = true
5
}

Update the changed flag, tells us that we made the changes in the index file and should commit those changes in the file.

1
func (i *Index) storeEntry(e *IndexEntry) {
2
    i.keys.Add(e.Path)
3
    i.entries[e.Path] = *e
4
}

This is easy we are just storing the Entries in our Index structure.

Storing Updates

Let’s update update our index writing function.

index.go

1
func (i *Index) WriteUpdate() (bool, error) {
2
  b, err := i.lockfile.holdForUpdate()
3
  if err != nil {
4
    return false, err
5
  }
6
  if !b {
7
    return false, nil
8
  }
9
  if !i.changed {
10
    return false, i.lockfile.rollback()
11
  }
12

13
  buf := new(bytes.Buffer) // makes a new buffer and returns its pointer
14

15
    // ...
16

17
    i.lockfile.commit()
18
   i.changed = false
19
    return true, nil

This checks if the changed flag is not true, then we will rollback any changes we made.

locfile.go

1
func (l *lockFile) rollback() error {
2
    l.mu.Lock()
3
    defer l.mu.Unlock()
4

5
    err := os.Remove(l.LockPath)
6
    if err != nil {
7
        return err
8
    }
9
    l.Lock = nil
10
    return nil
11
}

We created the rollback function to rollback any changes we might have made upto that point.

Committing from Index

Now that we are can incrementally update our index file, now it’s time to update our commit command to commit the files that are in the index file.

cmd/gitgo/cmdHandler.go

1
func cmdCommitHandler(_ string) error {
2
  rootPath := gitgo.ROOTPATH
3
  // storing all the blobs first
4
  entries, err := gitgo.StoreOnDisk(rootPath)
5
  if err != nil {
6
    return err
7
  }
8
  // build merkel tree, and store all the subdirectories tree file
9
  index := gitgo.NewIndex()
10
  index.Load()
11
  tree := gitgo.BuildTree(index.Entries())
12
  e, err := gitgo.TraverseTree(tree)
13
    if err != nil {
14
        return err
15
    }
16

17
    // ...
18

19
   // clear the file after the commit
20
   err = os.Remove(filepath.Join(gitgo.GITPATH, "index"))
21
   if err != nil {
22
       return err
23
   }
24

25
    return nil
26
}

Previously, we were building the tree from the whole files and directory in the root directory, but now we do not have to do that. We should now only build tree from the files that are provided to us in the index entry.

And after commit we are removing the index file so that all the index entries are removed.

We return the slice of Entries that is returned to us by index.Entries to our BuildTree function.

index.go

1
func (i *Index) Entries() []Entries {
2
    e := []Entries{}
3

4
    it := i.keys.Iterator()
5
    for it.Next() {
6
        path := it.Key()
7
        entry := i.entries[path]
8
        e = append(e, Entries{
9
            Path: path,
10
            OID: entry.Oid,
11
            Stat: strconv.Itoa(entry.Mode),
12
        })
13
    }
14

15
    return e
16
}

The function is pretty much straight forward, our key value in the Index structure uses the SortedSet that we implemented , and get traverse that set.

And, voilaa…

Now our gitgo can read from the index file to make a commit, how cool is that.

The problem

Well, our current implementation has a problem.

Let’s suppose we added file called file1.txt in our index file using the add command. And now we changed the file1.txt file to be a directory and added a new file in it like file1.txt/some.txt, now if we again use the add command. We can save this new change just fine, we do not have the problem there, but we want to update our file structure in the index file.

If you check your index file, you can see both the entries for the file1.txt and file1.txt/some.txt, we do not want that to happen. We want our index structure to remain consistent with the repository structure.

This can be true for the vice-versa of this condition, that a folder has been changed to the file.

But before go about updating the code to correct this error, we should do something else.

Test suites

Yes, till now we were not writing the test, not because I do not know how to write test, but because book never instructed me to do so. And know it did.

First let’s write a test case for adding a file to the index.

index_test.go

1
package gitgo
2

3
import (
4
    "crypto/rand"
5
    "encoding/hex"
6
    "os"
7
    "runtime"
8
    "testing"
9

10
  "github.com/stretchr/testify/assert"
11
)
12

13
// for testing purpose any random oid will do
14
func randomOID() string {
15
    b := make([]byte, 20)
16
    if _, err := rand.Read(b); err != nil {
17
        panic("failed to read random bytes: " + err)
18
    }
19

20
    return hex.EncodeToString(b)
21
}
22

23
// for testing purpose we will get the stats of this
24
// test file
25
func thisFileStat(t *testing.T) os.FileInfo {
26
    // locate this test file
27
    _, thisFile, _, ok := runtime.Caller(0)
28
    if !ok {
29
        t.Fatal("could not get current test filename")
30
    }
31
    fi, err := os.Stat(thisFile)
32
    if err != nil {
33
        t.Fatalf("stat test file: %v", err)
34
    }
35

36
    return fi
37
}
38

39
func TestAddSingleFile(t *testing.T) {
40
    // create a temp dir for this test and act the
41
    // repo root dir
42
    tmpDir := t.TempDir()
43
    ROOTPATH = tmpDir
44

45
    idx := NewIndex()
46
    oid := randomOID()
47
    stat := thisFileStat(t)
48

49
    idx.Add("alice.txt", oid, stat)
50

51
    entries := idx.Entires()
52

53
    var got []string
54
    for _, e := range entries {
55
        got = append(got, e.Path)
56
    }
57

58
    expected := []string{"alice.txt"}
59
    assert.Equal(t, expected, got)
60
}

I’m making use of the testify package, for asserts in testing, rather using the Go’s table-driven tests_ because I like this way.

Run the test and it should pass(fingers crossed).

Replacing file with directory

Now let’s write the test case for the problem we described earlier.

index_test.go

1
func TestReplaceFileWithDir(t *testing.T) {
2
    index := NewIndex()
3

4
    index.Add("alice.txt", randomOID(), thisFileStat(t))
5
    index.Add("bob.txt", randomOID(), thisFileStat(t))
6

7
    index.Add("alice.txt/nested.txt", randomOID(), thisFileStat(t))
8

9
    expected := []string{"alice.txt/nested.txt", "bob.txt"}
10
    var got []string
11
    it := index.keys.Iterator()
12
    for it.Next() {
13
        got = append(got, it.Key())
14
    }
15

16
    assert.Equal(t, expected, got)
17
}

This test case should fail, because we did not have any mechanism in place to correct this bug. You can call that we are now doing table driven development(TDD) (uncle bob will be happy with our progress).

index.go

1
func (i *Index) Add(path, oid string, stat os.FileInfo) {
2
    entry := NewIndexEntry(path, oid, stat)
3
+   i.discardConflict(entry)
4
    i.storeEntry(entry)
5
    i.changed = true
6
}

1
func (i *Index) discardConflict(e *IndexEntry) {
2
    var dirPaths []string
3
    d := filepath.Dir(e.Path)
4
    dirPaths = append(dirPaths, d)
5
    for d != "." && d != ".." && d != string(filepath.Separator) {
6
        d = filepath.Dir(d)
7
        dirPaths = append(dirPaths, d)
8
    }
9

10
    // Remove files if they are now changed to dir
11
    for _, dirPath := range dirPaths {
12
        i.keys.Remove(dirPath)
13
        delete(i.entries, dirPath)
14
    }
15
}

Now run the test and it should pass.

That’s one problem fixed.

Replace directory with file

Let’s write a test case for vice-versa case of the problem we just solved above.

index_test.go

1
func TestReplaceDirWithFile(t *testing.T) {
2
    index := NewIndex()
3

4
    index.Add("alice.txt", randomOID(), thisFileStat(t))
5
    index.Add("nested/bob.txt", randomOID(), thisFileStat(t))
6
    index.Add("nested", randomOID(), thisFileStat(t))
7

8
  expected := []string{"alice.txt", "nested"}
9
  var got []string
10
  it := index.keys.Iterator()
11
  for it.Next() {
12
    got = append(got, it.Key())
13
  }
14

15
  assert.Equal(t, expected, got)
16
}
17

18
func TestReplaceNestedDirWithFile(t *testing.T) {
19
  index := NewIndex()
20

21
  index.Add("alice.txt", randomOID(), thisFileStat(t))
22
  index.Add("nested/bob.txt", randomOID(), thisFileStat(t))
23
  index.Add("nested/inner/claire.txt", randomOID(), thisFileStat(t))
24
  index.Add("nested", randomOID(), thisFileStat(t))
25

26
  expected := []string{"alice.txt", "nested"}
27
  var got []string
28
  it := index.keys.Iterator()
29
  for it.Next() {
30
    got = append(got, it.Key())
31
  }
32

33
  assert.Equal(t, expected, got)
34
}

In this case, we have a dir nested that has a file bob.txt but in the next add command, we changed the structure and nested became a file. And same for the nested with the nested files.

To update our code to correct this, thing we will have to change our Index struct. Currently, we storing things like this

1
index.keys = SortedSet([
2
    "alice.txt",
3
    "nested/bob.txt",
4
    "nexted/inner/claire.txt",
5
])
6

7
index.entries = {
8
    "alice.txt"               => Entries{}
9
    "nested/bob.txt"          => Entries{}
10
    "nexted/inner/claire.txt" => Entries{}
11
}

To remove the nested directories, we will have to traverse all the parents of the file and check if any change in the structure happened for all the files, let’s not do that.

We will use a new parameter parents in our index structure that will be the map of map[string]Set that will store the directory as key and all its inner files in a Set.

Well, we do not have the Set in go, so let’s create one.

internal/datastr/set.go

1
package datastr
2

3
import (
4
    "iter"
5
    "slices"
6
)
7

8
type Set struct {
9
    arr []string
10
}
11

12
func NewSet() *Set {
13
    return &Set{}
14
}
15

16
// Add value in the slice if not found
17
func (s *Set) Add(val string) {
18
    found := slices.Contains(s.arr, val)
19
    if found {
20
        return
21
    }
22
    s.arr = append(s.arr, val)
23
}
24

25
// Remove value if found
26
func (s *Set) Remove(val string) {
27
    found := slices.Contains(s.arr, val)
28
    if !found {
29
        return
30
    }
31
    idx := slices.Index(s.arr, val)
32
    s.arr = slices.Delete(s.arr, idx, idx)
33
}
34

35
// Return the iterator on the set
36
func (s *Set) All() iter.Seq2[int, string] {
37
    return slices.All(s.arr)
38
}
39

40
func (s *Set) GetAll() []string {
41
    return s.arr
42
}
43

44
func (s *Set) IsEmpty() bool {
45
    return len(s.arr) == 0
46
}

Simple right…?

index.go

1
type Index struct {
2
  entries  map[string]IndexEntry
3
  keys     *datastr.SortedSet
4
  lockfile *lockFile
5
  changed  bool
6
+  parents  map[string]*datastr.Set
7
}
8

9
func NewIndex() *Index {
10
  return &Index{
11
    entries:  make(map[string]IndexEntry),
12
    keys:     datastr.NewSortedSet(),
13
    lockfile: lockInitialize(filepath.Join(GITPATH, "index")),
14
    changed:  false,
15
+    parents:  make(map[string]*datastr.Set),
16
  }
17
}

Now we store an entry, we iterator over its parent directories and add the entry’s path to each directories set in index.parent

1
func (i *Index) storeEntry(e *IndexEntry) {
2
    i.keys.Add(e.Path)
3
    i.entries[e.Path] = *e
4

5
    var parents []string
6
    p := filepath.Dir(e.Path)
7
    parents = append(parents, p)
8

9
    for p != "." && p != ".." && p != string(filepath.Separator) {
10
        p = filepath.Dir(p)
11
        parents = append(parents, p)
12
    }
13

14
    for _, p := range parents {
15
        pSet, ok := i.parents[p]
16
        if !ok {
17
            pSet = datastr.NewSet()
18
            i.parents[p] = pSet
19
        }
20
        pSet.Add(e.Path)
21
    }
22
}

With the parents added we can now extend our discardConflict function to remove the directories that conflict with the file.

1
func (i *Index) discardConflict(e *IndexEntry) {
2

3
+   // Remove dirs if they are now changed to file
4
+   i.removeChildren(e.Path)
5
}

1
func (i *Index) removeChildren(p string) {
2
    pSet, ok := i.parents[p]
3
    if !ok {
4
        return
5
    }
6
    original := pSet.GetAll()
7
    children := make([]string, len(original))
8
    copy(children, original)
9
    for _, child := range children {
10
        i.removeEntry(child)
11
    }
12
}
13

14
func (i *Index) removeEntry(path string) {
15
    entry, ok := i.entries[path]
16
    if !ok {
17
        return
18
    }
19
    i.keys.Remove(entry.Path)
20
    delete(i.entries, entry.Path)
21

22
    var dirPaths []string
23
    d := filepath.Dir(path)
24
    dirPaths = append(dirPaths, d)
25
    for d != "." && d != ".." && d != string(filepath.Separator) {
26
        d = filepath.Dir(d)
27
        dirPaths = append(dirPaths, d)
28
    }
29

30
    for _, d := range dirPaths {
31
        dir := d
32
        i.parents[dir].Remove(entry.Path)
33
        if i.parents[dir].IsEmpty() {
34
            delete(i.parents, dir)
35
        }
36
    }
37
}

Woooohhhh, with this we are now done, with the current updates, now run the tests and we should pass all the test cases. I am passing all my test cases.

Handling Bad inputs

Our current implementation of the add command works very great, but under an assumption that our user is intelligent and will always provide us with the correct file or directory input. Alas, that is not always the case. The user might accidently provide the wrong filename or a filename that might not even exists in the repository.

Handling non-existent file

Now, we want to handle the bad input that our user might throw at us. Let’s see how, git handles this?

1
mkdir gitgo-test && cd gitgo-test
2
touch main.go
3
git init

Now we will add the main.go file and another file that does not exists in the repository.

1
❯ git add main.go no-such-file
2
fatal: pathspec 'no-such-file' did not match any files

We get a fatal error telling us that the file does not exists. And if you try to check the index file, it does not exists, the git did not added any file what so ever if one such file do not exists.

1
❯ cat .git/index
2
cat: .git/index: No such file or directory

So, for replicating that we will have to update our cmdAddHandler first to add all the files in a slice using the ListFiles function, we want this function to return an error if the file do not exists in the actual repository. If it returns the error we will then exit the function early and return the error indicating failure. If error does not occur in the ListFiles function that we can iterate over the slice in which we added all the file paths and do the normal thing that we were doing.

In our cmdAddHandler function we will have to update the iteration block, as we did in the code snippet below.

cmd/gitgo/cmdHandler.go

1
// @@ -112,39 +112,46 @@ func cmdCatFileHandler(hash string) error {
2
 func cmdAddHandler(args []string) error {
3
   // index := gitgo.NewIndex()
4
   _, index := gitgo.IndexHoldForUpdate()
5
  var filePaths []string
6

7
  // add all the paths to a slice first
8
   for _, path := range args {
9
     absPath, err := filepath.Abs(path)
10
     if err != nil {
11
       return err
12
     }
13
     expandPaths, err := gitgo.ListFiles(absPath)
14
    if err != nil {
15
      index.Release()
16
      return err
17
    }
18
    filePaths = append(filePaths, expandPaths...)
19
  }
20

21
  for _, p := range filePaths {
22
    ap, err := filepath.Abs(p)
23
    if err != nil {
24
      return err
25
    }
26

27
    data, err := os.ReadFile(ap)
28
     if err != nil {
29
       return err
30
     }
31
    for _, p := range expandPaths {
32
      ap, err := filepath.Abs(p)
33
      if err != nil {
34
        return err
35
      }
36

37
      data, err := os.ReadFile(ap)
38
      if err != nil {
39
        return err
40
      }
41
      stat, err := os.Stat(ap)
42
      if err != nil {
43
        return err
44
      }
45

46
      blob := gitgo.Blob{Data: data}.Init()
47
      hash, err := blob.Store()
48
      if err != nil {
49
        return err
50
      }
51

52
      index.Add(p, hash, stat)
53
    stat, err := os.Stat(ap)
54
    if err != nil {
55
      return err
56
     }
57

58
    blob := gitgo.Blob{Data: data}.Init()
59
    hash, err := blob.Store()
60
    if err != nil {
61
      return err
62
    }
63

64
    index.Add(p, hash, stat)
65
   }
66

67
   res, err := index.WriteUpdate()
68
   if err != nil {
69
     return err

In our ListFiles function we are just now checking if our syscall to the Stat on the file or directory name returned any error. If it did that would possibly means(not neccessarily) that the file is not present in the actual repository.

files.go

1
// @@ -1,12 +1,15 @@
2
 package gitgo
3

4
 import (
5
  "errors"
6
   "fmt"
7
   "io/fs"
8
   "os"
9
   "path/filepath"
10
 )
11

12
var ErrMissingFile = errors.New("no file with the name")
13

14
 // Returns the flatten directory structure
15
 func ListFiles(dir string) ([]string, error) {
16
   var workfiles []string
17
// @@ -18,6 +21,10 @@ func ListFiles(dir string) ([]string, error) {
18

19
     // check if the given dir string is file or dir ?
20
     s, err := os.Stat(path)
21
    // if file is not present
22
    if os.IsNotExist(err) {
23
      return fmt.Errorf("%w '%s'", ErrMissingFile, dir)
24
    }
25
     if !s.IsDir() {
26
       relPath, err := filepath.Rel(dir, path)
27
       if err != nil {

Now, if we encounter the above mentioned error, we want to release the lock that we have on the index file so that when the next instance of the gitgo runs it does not file index.lock file.

index.go

1
// @@ -423,3 +423,5 @@ func writeIndexEntry(entry IndexEntry) ([]byte, error) {
2
   }
3
   return b.Bytes(), nil
4
 }
5

6
func (i *Index) Release() error { return i.lockfile.rollback() }

Easy.

Unreadable File

Now, there might happen that the reader have given us a filename, that we cannot read(i.e. we do not have the appropriate permission to do so). Let’s see what happens in the git when we do this.

1
❯ chmod -r main.go
2
❯ git add main.go
3
error: open("main.go"): Permission denied
4
error: unable to index file 'main.go'
5
fatal: adding files failed

I changed the permission our file by removing the reading permission and as we can see we cannot use the syscall open because we do that have the permission to do so. The git reported that error.

cmd/gitgo/cmdHandler.go

1
// @@ -136,6 +136,9 @@ func cmdAddHandler(args []string) error {
2

3
     data, err := os.ReadFile(ap)
4
     if err != nil {
5
      if os.IsPermission(err) {
6
        return fmt.Errorf("%w '%s'\nFatal: adding files failed", os.ErrPermission, p)
7
      }
8
       return err
9
     }
10
     stat, err := os.Stat(ap)

In our case the fix is very easy for us, we just want to give a better error message to our user.

Locked Index file

We can trigger the git’s error handler in case there is already a .git/index.lock file present.

1
❯ touch .git/index.lock
2
❯ git add main.go
3
fatal: Unable to create '/home/viku/Workspace/personal/go/tests/gitgo-test/.git/index.lock': File exists.
4

5
Another git process seems to be running in this repository, e.g.
6
an editor opened by 'git commit'. Please make sure all processes
7
are terminated then try again. If it still fails, a git process
8
may have crashed in this repository earlier:
9
remove the file manually to continue.

In the book, it said that the message e.g an editor opened by git commit is now not true for the git as while the git opens the commit file at that time it does not have the lock for the index file. So we can just remove this example message in our implementation.

Now in our IndexHoldForUpdate we want to return an error, if the file is already present.

index.go

1
// @@ -60,20 +60,20 @@ func (i *Index) Entries() []Entries {
2
   return e
3
 }
4

5
func IndexHoldForUpdate() (bool, *Index) {
6
func IndexHoldForUpdate() (bool, *Index, error) {
7
   index := NewIndex()
8
   b, err := index.lockfile.holdForUpdate()
9
   if err != nil {
10
    return false, nil
11
    return false, index, err
12
   }
13
   if !b {
14
    return false, nil
15
    return false, index, nil
16
   }
17

18
   // load the index file
19
   err = index.Load()
20

21
  return true, index
22
  return true, index, nil
23
 }
24

25
 func (i *Index) Load() error {

In our lockfile implementation we are now making a check in the error handling, if the file already exists(also I have updated how I am checking for the errors).

lockfile.go

1
// @@ -5,6 +5,7 @@ import (
2
   "log"
3
   "os"
4
   "sync"
5
  "syscall"
6
 )
7

8
 var (
9
@@ -31,18 +32,23 @@ func lockInitialize(path string) *lockFile {
10
 func (l *lockFile) holdForUpdate() (bool, error) {
11
   l.mu.Lock()
12
   defer l.mu.Unlock()
13

14
   if l.Lock != nil {
15
    return true, nil // lock already aquired
16
   }
17

18
   file, err := os.OpenFile(l.LockPath, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0644)
19
   if err != nil {
20
    if os.IsExist(err) {
21
      return false, nil
22
    } else if os.IsNotExist(err) {
23
      return false, ErrMissingParent
24
    } else if os.IsPermission(err) {
25
      return false, ErrNoPermission
26
    var pathErr *os.PathError
27
    if errors.As(err, &pathErr) {
28
      switch pathErr.Err {
29
      case syscall.EEXIST:
30
        return false, ErrLockDenied
31
      case syscall.ENOENT:
32
        return false, ErrMissingParent
33
      case syscall.EACCES:
34
        return false, ErrNoPermission
35
      }
36
     }
37
     return false, err
38
   }

Now we can update our ref file, to better reflect our update in the lockfile.

1
// @@ -2,7 +2,6 @@ package gitgo
2

3
 import (
4
   "errors"
5
  "fmt"
6
   "os"
7
   "path/filepath"
8
 )
9
@@ -23,8 +22,8 @@ func RefInitialize(pathname string) ref {
10
 func (r ref) UpdateHead(oid []byte) error {
11
   lockfile := lockInitialize(r.headPath)
12

13
  if lock, _ := lockfile.holdForUpdate(); !lock {
14
    return fmt.Errorf("Err: %s\nCould not aquire lock on file: %s", ErrLockDenied, r.headPath)
15
  if _, err := lockfile.holdForUpdate(); err != nil {
16
    return err
17
   }
18

19
   oid = append(oid, '\n')

And lastly the cmdAddHandler, we are now returning a better error message.

cmd/gitgo/cmdHandler.go

1
// @@ -111,7 +111,16 @@ func cmdCatFileHandler(hash string) error {
2

3
 func cmdAddHandler(args []string) error {
4
   // index := gitgo.NewIndex()
5
  _, index := gitgo.IndexHoldForUpdate()
6
  _, index, err := gitgo.IndexHoldForUpdate()
7
  if err != nil {
8
    return fmt.Errorf(`
9
Fatal: %w
10

11
Another gitgo process seems to be running in this repository.
12
Please make sure all processes are terminated then try again.
13
If it still fails, a gitgo process may have crashed in this
14
repository earlier: remove the file manually to continue.`, err)
15
  }
16
   var filePaths []string
17

18
   // add all the paths to a slice first

And now we are done with the implementation of the git’s add command.

Afterword

In this blog, we updated our add command to do the following

Parsing the index file.
Add the files in the incremental manner.
Commit from the index file.
Handling the bad input.

Code Link: Github

Just know this,

Reinvent the wheel, so that you can learn how to invent wheel

– a nobody

#git

#go

#system-tools