Branch support (#7)
Test Workflow / Lint and test library (push) Successful in 1m51s Details
Publish Workflow / Publish library (push) Successful in 2m18s Details

Closes #6.

Implements branch support by _only extending_ the existing functionality. Note that the existing functionality DOES NOT implement a `parent` pointer for commits, and as a result branches are also implemented differently to how git implements them.

git branches are simply a named pointer to a commit object (which then has a pointer to its parent commit), here branches store the entire sequence of pointers to commit objects.

### Why different to git?
I made a mistake in the initial implementation by using a `TreeSet` instead of manually implementing a tree for commits. This allowed the ability to insert commits in-between other commits, which isn't normally possible in `git` _without rebasing which changes commits' hashes_.

The specification for this feature stated:
> All functionality that is implemented already should be preserved.

And so since I cannot remove this functionality any more, I have to build on top of it.

Reviewed-on: #7
This commit is contained in:
Gleb Koval 2024-01-10 12:21:25 +00:00
parent 7233a7e8d1
commit dbc1bdd105
2 changed files with 74 additions and 6 deletions

View File

@ -1,5 +1,7 @@
package tinyvm
import java.util.TreeSet
class HashCollisionException(hash: String) : Exception("Different object types with identical hash '$hash'")
private class CommitTimeComparator : Comparator<Commit> {
@ -9,14 +11,49 @@ private class CommitTimeComparator : Comparator<Commit> {
): Int = (o1.timestamp.epochSecond - o2.timestamp.epochSecond).toInt()
}
class Repository {
private val commits = sortedSetOf(CommitTimeComparator())
private val commitTimeComparator = CommitTimeComparator()
private class Branch(val name: String, val commits: TreeSet<Commit>)
class Repository(initialBranch: String = "master") {
private var head = Branch(initialBranch, sortedSetOf(commitTimeComparator))
private val commits = mutableMapOf(initialBranch to head)
val branch: String
get() = head.name
val branches: Set<String>
get() = commits.keys
// Store all objects in one map like git does. This would simplify the data persistence implementation (if there was
// one) and allows for other objects to be added in the future without modifying the data persistence implementation
// at all.
private val objects = mutableMapOf<String, Object>()
/**
* Create a new branch as a copy of the current branch.
* @param name New branch name.
* @param use Whether to switch to this branch.
*/
fun createBranch(
name: String,
use: Boolean = true,
) {
commits[name] =
Branch(
name,
head.commits.clone() as? TreeSet<Commit> ?: throw Exception("TreeSet.clone() unexpected result"),
)
if (use) useBranch(name)
}
/**
* Use (switch to) a branch.
*/
fun useBranch(name: String) {
head = commits[name] ?: throw BranchNotFoundException(name)
}
/**
* (Deep) get or put a commit object into the repository.
* This will also get or put all child trees and blobs.
@ -33,7 +70,7 @@ class Repository {
timestamp = commit.timestamp,
)
objects[hash] = newCommit
commits.add(newCommit)
head.commits.add(newCommit)
return newCommit
}
@ -45,12 +82,12 @@ class Repository {
/**
* List all commits.
*/
fun listCommits(): List<Commit> = commits.toList()
fun listCommits(): List<Commit> = head.commits.toList()
/**
* Find commit.
*/
fun findCommit(predicate: (Commit) -> Boolean): Commit? = commits.find(predicate)
fun findCommit(predicate: (Commit) -> Boolean): Commit? = head.commits.find(predicate)
/**
* Dump repository objects
@ -90,3 +127,5 @@ class Repository {
private inline fun <reified T : Object> findObject(hash: String): T? =
objects[hash]?.let { it as? T ?: throw HashCollisionException(hash) }
}
class BranchNotFoundException(name: String) : Exception("Branch '$name' does not exist")

View File

@ -118,6 +118,35 @@ internal class RepositoryTest {
assertEquals(null, repository.getCommit("00000000000000000000"))
}
@Test
fun `can create and use branch`() {
repository.commit(commits[0])
repository.commit(commits[1])
repository.commit(commits[2])
repository.createBranch("test-branch", use = false)
assertEquals("master", repository.branch)
repository.createBranch("test-branch-2")
assertEquals("test-branch-2", repository.branch)
assertEquals(setOf("master", "test-branch", "test-branch-2"), repository.branches)
assertEquals(commits.map { it.hash() }, repository.listCommits().map { it.hash() })
assertEquals(10, repository.dumpObjects().size)
}
@Test
fun `can commit to branch`() {
repository.commit(commits[0])
repository.createBranch("test-branch")
repository.commit(commits[1])
repository.createBranch("test-branch-2")
repository.commit(commits[2])
assertEquals(commits.map { it.hash() }, repository.listCommits().map { it.hash() })
repository.useBranch("test-branch")
assertEquals(commits.take(2).map { it.hash() }, repository.listCommits().map { it.hash() })
repository.useBranch("master")
assertEquals(commits.take(1).map { it.hash() }, repository.listCommits().map { it.hash() })
}
@Test
fun `can display commit`() {
assertEquals(