Gitのローカルリポジトリを解析して履歴を再現する

type Repository interface {
  GetCommit(hash string) (*object.Commit, errors.ServiceError)
  GetParents(commit *object.Commit) ([]*object.Commit, errors.ServiceError)
  ListCommits(end string) ([]*object.Commit, errors.ServiceError)
  GetTree(hash string) (*object.Tree, errors.ServiceError)
  GetDiff(current *object.Tree, prev *object.Tree) (object.Changes, errors.ServiceError)
  GetFileBody(file *object.File) (string, errors.ServiceError)
}

func (s *service) GetRepository(path string) (Repository, errors.ServiceError) {
  repo, err := git.PlainOpen(path)
  if err != nil {
     return nil, errors.NewFromError(err, errors.Internal, failure.Messagef("failed to open git repository %s", path))
  }

  return &repository{
     client: repo,
     path:   path,
  }, nil
}

func traverseCommitTree(root *object.Commit, baseHash string, branch string, res map[string]string) errors.ServiceError {
  res[root.Hash.String()] = branch

  var parents []*object.Commit
  if err := root.Parents().ForEach(func(commit *object.Commit) error {
     parents = append(parents, commit)
     return nil
  }); err != nil {
     return errors.NewFromError(err, errors.Internal)
  }

  // Base case:
  // 1. If there's no parents, stop traversing tree
  // 2. If it reached to the base hash, we don't want to include any more commit
  if len(parents) == 0 || parents[0].Hash.String() == baseHash {
     return nil
  }

  for i, parent := range parents {
     if i == 0 {
        // The first parent is always on the same branch as the child one, so just continue to traverse
        if err := traverseCommitTree(parent, baseHash, branch, res); err != nil {
           return err
        }
        continue
     }

     // The second or more parent is on a different branch than the child one,
     // then find the commit where two branches diverged
     commonAncestors, err := parent.MergeBase(parents[0])
     if err != nil {
        return errors.NewFromError(err, errors.Internal)
     }

     // Continue to traverse. Commits are on the new branch until we get to the junction found the above
     if err := traverseCommitTree(parent, commonAncestors[0].Hash.String(), fmt.Sprintf("unknown-%s", getRandomHash(5)), res); err != nil {
        return err
     }
  }

  return nil
}

[
  {
    "type": "CREATE_COMMIT",
    "hash": "c5cc7e47f2ada749022cf457df84f18fd26a2113",
    "message": "initial commit\n",
    "branch": "main",
    "date": "2022-12-12T23:44:23Z"
  },
  {
    "type": "CREATE_BRANCH",
    "name": "development"
  },
  {
    "type": "CREATE_COMMIT",
    "hash": "718e22c76d721686b5c4473335bebf306398edb6",
    "message": "implemented \n",
    "branch": "development",
    "date": "2022-12-12T23:47:36Z"
  },
  {
    "type": "MERGE_BRANCH",
    "hash": "9574a723826d65f8c16653baf5332540df848295",
    "source": "development",
    "destination": "main",
    "message": "merged development branch\n",
    "date": "2022-12-12T23:50:45Z"
  },
  {
    "type": "CREATE_COMMIT",
    "hash": "ae34c6b440b5e659aae4862525dfe346b03931a3",
    "message": "added new file\n",
    "branch": "main",
    "date": "2022-12-12T23:51:35Z"
  }
]

[
  {
    "hash": "a3516a1d7cdbfac71b40f36c45c7cb1e27ac0bfa",
    "parent": "c5cc7e47f2ada749022cf457df84f18fd26a2113",
    "diffs": [
      {
        "operation": "MODIFICATION",
        "from_path": "src/App.tsx",
        "to_path": "src/App.tsx",
        "from_body": "",
        "to_body": ""
      }
    ],
    "date": "2022-12-12T23:47:12Z"
  },
  {
    "hash": "b27426766675d0ccc5c4ef0e9991ac63ab714009",
    "parent": "c5cc7e47f2ada749022cf457df84f18fd26a2113",
    "diffs": [
      {
        "operation": "MODIFICATION",
        "from_path": "README.md",
        "to_path": "README.md",
        "from_body": "",
        "to_body": ""
      }
    ],
    "date": "2022-12-12T23:47:57Z"
  },
  {
    "hash": "ae34c6b440b5e659aae4862525dfe346b03931a3",
    "parent": "9574a723826d65f8c16653baf5332540df848295",
    "diffs": [
      {
        "operation": "ADDITION",
        "from_path": "",
        "to_path": "new.txt",
        "from_body": "",
        "to_body": ""
      }
    ],
    "date": "2022-12-12T23:51:35Z"
  }
]

func getFileDiffs(commits []*object.Commit, repo git.Repository) (map[string]map[string]fileDiff, errors.ServiceError) {
  commitFileDiffMap := map[string]map[string]fileDiff{}

  for _, commit := range commits {
     parents, serr := repo.GetParents(commit)
     if serr != nil {
        return nil, serr
     }

     tree, serr := repo.GetTree(commit.TreeHash.String())
     if serr != nil {
        return nil, serr
     }

     var parentTree *object.Tree
     if len(parents) > 0 {
        parentTree, serr = repo.GetTree(parents[0].TreeHash.String())
        if serr != nil {
           return nil, serr
        }
     }

     changes, serr := repo.GetDiff(tree, parentTree)
     if serr != nil {
        return nil, serr
     }

     for _, change := range changes {
        from, to, err := change.Files()
        if err != nil {
           return nil, errors.NewFromError(err, errors.Internal)
        }

        // lazy initialization
        if commitFileDiffMap[commit.Hash.String()] == nil {
           commitFileDiffMap[commit.Hash.String()] = map[string]fileDiff{}
        }

        if from == nil && to != nil {
           // addition
           toBody, serr := repo.GetFileBody(to)
           if serr != nil {
              return nil, serr
           }

           commitFileDiffMap[commit.Hash.String()][change.To.Name] = fileDiff{
              Operation: Addition,
              ToPath:    change.To.Name,
              ToBody:    toBody,
           }
        } else if from != nil && to == nil {
           // deletion
           fromBody, serr := repo.GetFileBody(from)
           if serr != nil {
              return nil, serr
           }

           commitFileDiffMap[commit.Hash.String()][change.From.Name] = fileDiff{
              Operation: Deletion,
              FromPath:  change.From.Name,
              FromBody:  fromBody,
           }
        } else if from != nil && to != nil && change.To.Name == change.From.Name {
           // modification
           fromBody, serr := repo.GetFileBody(from)
           if serr != nil {
              return nil, serr
           }

           toBody, serr := repo.GetFileBody(to)
           if serr != nil {
              return nil, serr
           }

           commitFileDiffMap[commit.Hash.String()][change.To.Name] = fileDiff{
              Operation: Modification,
              FromPath:  change.To.Name,
              ToPath:    change.To.Name,
              FromBody:  fromBody,
              ToBody:    toBody,
           }
        } else if from != nil && to != nil && change.To.Name != change.From.Name {
           // rename
           fromBody, serr := repo.GetFileBody(from)
           if serr != nil {
              return nil, serr
           }

           toBody, serr := repo.GetFileBody(to)
           if serr != nil {
              return nil, serr
           }

           commitFileDiffMap[commit.Hash.String()][change.To.Name] = fileDiff{
              Operation: Rename,
              FromPath:  change.From.Name,
              ToPath:    change.To.Name,
              FromBody:  fromBody,
              ToBody:    toBody,
           }

        }
     }
  }

  return commitFileDiffMap, nil
}

{
  "operation": "MODIFICATION",
  "from_path": "src/App.tsx",
  "to_path": "src/App.tsx",
  "from_body": "old body",
  "to_body": "new body"
}