Building Git Part 5

func main() {
    // ....
    switch os.Args[1] {
    // ....

    case "add":
        err := cmdAddHandler(os.Args[1])
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error: %s\n", err)
            os.Exit(1)
        }
    }

    // ...
}

func cmdAddHandler(args string) error {
    path := args
    data, err := os.ReadFile(path)
    if err != nil {
        return err
    }
    stat, err := os.Stat(path)
    if err != nil {
        return err
    }

    blob := gitgo.Blob{Data: data}.Init()
    hash, err := blob.Store()
    if err != nil {
        return err
    }

    index := gitgo.NewIndex()
    index.Add(path, hash, stat)
    res, err := index.WriteUpdate()
    if err != nil {
        return err
    }
}

package gitgo

import (
    "os"
    "syscall"
)

const (
    maxPathSize = 0xfff
    regularMode = 0100644
    executableMode = 0100755
)

type IndexEntry struct {
    Path string
    Oid string
    Mtime int64
    MtimeNsec int64
    Ctime int64
    CtimeNsec int64
    Dev uint64
    Ino uint64
    Mode int
    Uid uint32
    Gid uint32
    Size int64
    Flags uint32
}

func NewIndexEntry(name, oid string, stat os.FileInfo) *IndexEntry {
    s := stat.Sys().(*syscall.Stat_t)
    flags := min(len(name), maxPathSize)
    var m int
    if stat.Mode()&0111 != 0 {
        m = executbleMode
    } else {
        m = regularMode
    }

    return &IndexEntry{
        Path: name,
        Oid: oid,
        Mtime: s.Mtim.Sec,
        MtimeNsec: s.Mtim.Nsec,
        Ctime: s.Ctim.Sec,
        CtimeNsec: s.Ctime.Nsec,
        Dev: s.Dev,
        Ino: s.Ino,
        Mode: m,
        Uid: s.Uid,
        Gid: s.Gid,
        Size: s.Size,
        Flags: uint32(flags),
    }
}

package gitgo

import (
    "bytes"
    "crypto/sha1"
    "encoding/binary"
    "encoding/hex"
    "fmt"
    "os"
    "path/filepath"
)

type Index struct {
    // for storing multiple file data, for future progress
    // i guess?
    entries map[string]IndexEntry
    // for evading the race condition like we did with the
    // head file writing
    lockfile *lockFile
}

// Initializing the Index struct with the lockfile for the
// `.gitgo/index` file.
func NewIndex() *Index {
    return &Index{
        entries: make(map[string]IndexEntry),
        lockfile: lockInitialze(filepath.Join(GITPATH, "index"))
    }
}

// Adding the file to the index
func (i *Index) Add(path, oid string, stat os.FileInfo) {
    entry := NewIndexEntry(path, oid, stat)
    i.entries[path] = *entry
}

func (i *Index) WriteUpdate() (bool, error) {
    // getting the lock on the index file
    b, err := i.lockfile.holdForUpdate()
    if err != nil {
        return false, err
    }
    if !b {
        return false, nil
    }

    // make a new buffer and return its pointer
    buf := new(bytes.Buffer)
    writeHeader(buf, len(i.entries))
    for _, entry := range i.entries {
        b, err := writeIndexEntry(entry)
        if err != nil {
            return true, err
        }
        buf.Write(b)
    }

    // getting the hash of the whole content in the
    // index file
    content := buf.Bytes()
    bufHash := sha1.Sum(content)
    buf.write(bufHash[:])

    i.lockfile.write(buf.Bytes())
    i.lockfile.commit()
    return true, nil
}

func writeHeader(buf *bytes.Buffer, entryLen int) error {
    _, err := buf.Write([]byte("DIRC"))
    if err != nil {
        return fmt.Errorf("writing index header: %s", err)
    }

    b := new(bytes.Buffer)
    versionNum := unit32(2)
    entriesNum := unit32(entryLen)
    binary.Write(b, binary.BigEndian, versionNum)
    binary.Write(b, binary.BigEndian, entriesNum)

    _, err = buf.Write(b.Bytes())
    if err != nil {
        return fmt.Errorf("writing index header: %s", err)
    }
    return nil
}

func writeIndexEntry(entry IndexEntry) ([]byte, error) {
	b := new(bytes.Buffer)
	err := binary.Write(b, binary.BigEndian, uint32(entry.Ctime))
	if err != nil {
		return nil, fmt.Errorf("writing ctime: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.CtimeNsec))
	if err != nil {
		return nil, fmt.Errorf("writing ctime nsec: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Mtime))
	if err != nil {
		return nil, fmt.Errorf("writing mtime: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.MtimeNsec))
	if err != nil {
		return nil, fmt.Errorf("writing mtime nsec: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Dev))
	if err != nil {
		return nil, fmt.Errorf("writing dev: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Ino))
	if err != nil {
		return nil, fmt.Errorf("writing ino: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Mode))
	if err != nil {
		return nil, fmt.Errorf("writing mode: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Uid))
	if err != nil {
		return nil, fmt.Errorf("writing uid: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Gid))
	if err != nil {
		return nil, fmt.Errorf("writing gid: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint32(entry.Size))
	if err != nil {
		return nil, fmt.Errorf("writing size: %s", err)
	}
	oid, err := hex.DecodeString(entry.Oid)
	if err != nil {
		return nil, fmt.Errorf("decoding string oid: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, oid)
	if err != nil {
		return nil, fmt.Errorf("writing oid: %s", err)
	}
	err = binary.Write(b, binary.BigEndian, uint16(entry.Flags))
	if err != nil {
		return nil, fmt.Errorf("writing flag: %s", err)
	}
	_, err = b.Write([]byte(entry.Path))
	if err != nil {
		return nil, fmt.Errorf("writing entry path: %s", err)
	}
	err = b.WriteByte(0)
	if err != nil {
		return nil, fmt.Errorf("writing null byte after entry: %s", err)
	}
	missing := (8 - (b.Len() % 8)) % 8
	for range missing {
		b.WriteByte(0)
	}
	return b.Bytes(), nil
}

  type Index struct {
  	entries  map[string]IndexEntry
+	keys     *datastr.SortedSet
  	lockfile *lockFile
  }

  func NewIndex() *Index {
  	return &Index{
  		entries:  make(map[string]IndexEntry),
+       keys:     datastr.NewSortedSet(),
  		lockfile: lockInitialize(filepath.Join(GITPATH, "index")),
  	}
  }

  func (i *Index) Add(path, oid string, stat os.FileInfo) {
  	entry := NewIndexEntry(path, oid, stat)
 +	i.keys.Add(path)
  	i.entries[path] = *entry
  }

  func (i *Index) WriteUpdate() (bool, error) {
  	b, err := i.lockfile.holdForUpdate()
  	if err != nil {
  		return false, err
  	}
  	if !b {
  		return false, nil
  	}

  	buf := new(bytes.Buffer) // makes a new buffer and returns its pointer
  	writeHeader(buf, len(i.entries))
 +	it := i.keys.Iterator()
 +	for it.Next() {
 +		path := it.Key()
 +		entry := i.entries[path]
 +		data, err := writeIndexEntry(entry)
 +		if err != nil {
 +			return true, err
 +		}
 +		buf.Write(data)
  	}

  	// getting the hash of the whole content in the
  	// index file
  	content := buf.Bytes()
  	bufHash := sha1.Sum(content)
  	buf.Write(bufHash[:])

  	i.lockfile.write(buf.Bytes())
  	i.lockfile.commit()
  	return true, nil
  }

func cmdAddHandler(args []string) error {
	index := gitgo.NewIndex()
	for _, path := range args {
		data, err := os.ReadFile(path)
		if err != nil {
			return err
		}
		stat, err := os.Stat(path)
		if err != nil {
			return err
		}

		blob := gitgo.Blob{Data: data}.Init()
		hash, err := blob.Store()
		if err != nil {
			return err
		}

		index.Add(path, hash, stat)
	}
	res, err := index.WriteUpdate()
	if err != nil {
		return err
	}

	if res {
		fmt.Println("Written data to Index file")
	}

	return nil
}

func ListFiles(dir string) ([]string, error) {
    var workfiles []string

    err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }

        // check if the given dir path is file or directory?
+       s, err := os.Stat(path)
+       if !s.IsDir() {
+           relPath, err := filepath.Rel(dir, path)
+           if err != nil {
+               return err
+           }
+           if relPath == "." {
+               relPath, err = filepath.Rel(ROOTPATH, path)
+               if err != nil {
+                   return err
+               }
+               workfiles = append(workfiles, relPath)
+               return nil
+           }
+       }
        name := filepath.Base(path)
        // skip the files or directories found in the ignore hashmap
        if _, found := g_ignore[name]; found {
            if d.IsDir() {
                return filepath.SkipDir
            }
            return nil
        }

        // Append only files, not directories
        if !d.IsDir() {
+           relPath, err := filepath.Rel(ROOTPATH, path)
+           if err != nil {
+               return err
+           }
            workfiles = append(workfiles, relPath)
        }
        return nil
    })
    if err != nil {
        return nil, err
    }
    return workfiles, nil
}

func cmdAddHandler(args []string) error {
    index := gitgo.NewIndex()
    for _, path := range args {
+       absPath, err := filepath.Abs(path)
+       if err != nil {
+           return err
+       }
+
+       expandPaths, err := gitgo.ListFiles(absPath)
+       if err != nil {
+           return err
+       }
+
+       for _, p := range expandPaths {
+           ap, err := filepath.Abs(p)
+           if err != nil {
+               return err
+           }

-           data, err := os.ReadFile(ap)
            if err != nil {
                return err
            }
-           stat, err := os.Stat(ap)
            if err != nil {
                return err
            }

            blob := gitgo.Blob{Data: data}.Init()
            hash, err := blob.Store()
            if err != nil {
                return err
            }

-           index.Add(p, hash, stat)
        }
    }
    res, err := index.WriteUpdate()
    if err != nil {
        return err
    }

    if res {
        fmt.Println("Written data to Index file")
    }
    return nil
}