Initial library implementations and tests

.github/workflows/main.yaml

@@ -0,0 +1,9 @@
+name: Main Workflow
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+jobs:

.github/workflows/publish.yaml

@@ -1,40 +0,0 @@
-name: Publish Workflow
-on:
-  push:
-    tags:
-      - v*
-jobs:
-  publish:
-    name: Publish library
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Java
-        uses: actions/setup-java@v3
-        with:
-          distribution: adopt
-          java-version: 17
-
-      - name: Verify Gradle wrapper
-        uses: gradle/wrapper-validation-action@v1
-
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2
-
-      - name: Run checks
-        run: ./gradlew check
-
-      - name: Parse parameters
-        id: parse
-        run: |
-          export VERSION="$(echo ${{ github.ref_name }} | cut -c2-)"
-          echo "Parsed version: '$VERSION'"
-          echo "tinyvm_version=$VERSION" >> "$GITHUB_OUTPUT"
-
-      - name: Publish to Gitea package repository
-        env:
-          TINYVM_VERSION: ${{ steps.parse.outputs.tinyvm_version }}
-          GITEA_USERNAME: ${{ github.repository_owner }}
-          GITEA_TOKEN: ${{ secrets.deploy_token }}
-        run: ./gradlew publishAllPublicationsToGiteaRepository

.github/workflows/test.yaml

@@ -1,29 +0,0 @@
-name: Test Workflow
-on:
-  pull_request:
-    branches:
-      - main
-  push:
-    branches:
-      - main
-jobs:
-  lint-and-test:
-    name: Lint and test library
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Java
-        uses: actions/setup-java@v3
-        with:
-          distribution: adopt
-          java-version: 17
-
-      - name: Verify Gradle wrapper
-        uses: gradle/wrapper-validation-action@v1
-
-      - name: Setup Gradle
-        uses: gradle/gradle-build-action@v2
-
-      - name: Run checks
-        run: ./gradlew check

.idea/gradle.xml

@@ -5,7 +5,6 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="corretto-19" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />

README.md

@@ -10,26 +10,6 @@ The package is named `tinyvm` for 'tiny version manager'.
 Since this is an internship application project, I have assumed that a minimal usage of external libraries is preferred,
 so that a greater technical understanding can be demonstrated.
 
-## Usage
-
-### Gradle
-```kotlin
-repositories {
-    // other repositories
-    maven { url "https://git.koval.net/api/packages/cyclane/maven" }
-}
-
-dependencies {
-    // other dependencies
-    implementation("net.koval.teamcity-gitea-test-task:tinyvm:0.1.1")
-}
-```
-
-### Documentation
-Use autocompletion and hover menus in your IDE, or download the
-[generated HTML documentation](https://git.koval.net/cyclane/teamcity-gitea-test-task/releases/download/v0.1.1/tinyvm-0.1.1-javadoc.zip)
-from the [latest release](https://git.koval.net/cyclane/teamcity-gitea-test-task/releases).
-
 ## Instructions
 
 Create a library that implements simple Git functionality. You need to implement at least three entities:

build.gradle.kts

@@ -1,12 +1,10 @@
 plugins {
     kotlin("jvm") version "1.9.21"
     id("org.jmailen.kotlinter") version "4.1.0"
-    id("org.jetbrains.dokka") version "1.9.10"
-    `maven-publish`
 }
 
-group = "net.koval.teamcity-gitea-test-task"
-version = System.getenv("TINYVM_VERSION")
+group = "net.koval"
+version = "1.0-SNAPSHOT"
 
 repositories {
     mavenCentral()
@@ -23,46 +21,3 @@ tasks.test {
 kotlin {
     jvmToolchain(17)
 }
-
-val dokkaHtml by tasks.getting(org.jetbrains.dokka.gradle.DokkaTask::class)
-val javadocJar: TaskProvider<Jar> by tasks.registering(Jar::class) {
-    dependsOn(dokkaHtml)
-    archiveClassifier.set("javadoc")
-    from(dokkaHtml.outputDirectory)
-}
-
-publishing {
-    publications.register<MavenPublication>("gpr") {
-        artifactId = "tinyvm"
-        from(components["java"])
-        artifact(javadocJar)
-        pom {
-            name.set("TeamCity support for Gitea - Test Task - tiny version manager")
-            description.set("This is a small project to implement a subset of git's functionality in Kotlin and was " +
-                "created using the instructions below as part of my application to the JetBrains internship project " +
-                "\"TeamCity support for Gitea\".")
-            url.set("https://git.koval.net/cyclane/teamcity-gitea-test-task")
-            developers {
-                developer {
-                    id.set("cyclane")
-                    name.set("Gleb Koval")
-                    email.set("gleb@koval.net")
-                }
-            }
-            scm {
-                url.set("https://git.koval.net/cyclane/teamcity-gitea-test-task")
-            }
-        }
-    }
-
-    repositories {
-        maven {
-            name = "Gitea"
-            url = uri("https://git.koval.net/api/packages/cyclane/maven")
-            credentials {
-                username = System.getenv("GITEA_USERNAME")
-                password = System.getenv("GITEA_TOKEN")
-            }
-        }
-    }
-}

src/main/kotlin/tinyvm/Commit.kt

@@ -1,25 +1,33 @@
 package tinyvm
 
+import java.security.MessageDigest
 import java.time.Instant
 
-/**
- * Commits are a pointer to a 'head' tree with some metadata.
- */
+abstract class Object(
+    val type: String,
+) {
+    abstract val data: String
+    fun hash(): String = MessageDigest
+        .getInstance("SHA-1")
+        .digest("$type ${data.length}\u0000$data".toByteArray())
+        .toHex()
+}
+
 class Commit(
     val tree: Tree,
     val author: Author,
     val message: String,
-    val timestamp: Instant,
+    val timestamp: Instant
 ) : Object("commit") {
+    // Use \n\n for end of header in-case additional metadata is implemented in the future.
     override val data: String
         get() = "tree ${tree.hash()}\nauthor $author\ntimestamp ${timestamp.epochSecond}\n\n$message"
-
-    override fun toString(): String = "commit ${hash()}\n$data"
 }
 
 data class Author(
     val name: String,
-    val email: String,
+    val email: String
 ) {
-    override fun toString(): String = "$name <$email>"
+    override fun toString(): String =
+        "$name <$email>"
 }

src/main/kotlin/tinyvm/Extensions.kt

@@ -0,0 +1,6 @@
+package tinyvm
+
+import java.util.HexFormat
+
+fun ByteArray.toHex(): String =
+     HexFormat.of().formatHex(this)

src/main/kotlin/tinyvm/Object.kt

@@ -1,17 +0,0 @@
-package tinyvm
-
-import java.security.MessageDigest
-import java.util.HexFormat
-
-/**
- * Represents an arbitrary version manager object.
- */
-abstract class Object(val type: String) {
-    abstract val data: String
-
-    fun hash(): String =
-        HexFormat.of().formatHex(
-            MessageDigest.getInstance("SHA-1")
-                .digest("$type ${data.length}\u0000$data".toByteArray()),
-        )
-}

src/main/kotlin/tinyvm/Repository.kt

@@ -1,59 +1,20 @@
 package tinyvm
 
-import java.util.TreeSet
-
 class HashCollisionException(hash: String) : Exception("Different object types with identical hash '$hash'")
 
-private class CommitTimeComparator : Comparator<Commit> {
-    override fun compare(
-        o1: Commit,
-        o2: Commit,
-    ): Int = (o1.timestamp.epochSecond - o2.timestamp.epochSecond).toInt()
+class CommitTimeComparator: Comparator<Commit> {
+    override fun compare(o1: Commit, o2: Commit): Int =
+        (o1.timestamp.epochSecond - o2.timestamp.epochSecond).toInt()
 }
 
-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
+class Repository {
+    private val commits = sortedSetOf(CommitTimeComparator())
 
     // 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.
@@ -62,15 +23,14 @@ class Repository(initialBranch: String = "master") {
         val hash = commit.hash()
         val obj = findObject<Commit>(hash)
         if (obj != null) return obj
-        val newCommit =
-            Commit(
-                tree = addTree(commit.tree),
-                author = commit.author,
-                message = commit.message,
-                timestamp = commit.timestamp,
-            )
+        val newCommit = Commit(
+            tree = addTree(commit.tree),
+            author = commit.author,
+            message = commit.message,
+            timestamp = commit.timestamp
+        )
         objects[hash] = newCommit
-        head.commits.add(newCommit)
+        commits.add(newCommit)
         return newCommit
     }
 
@@ -82,12 +42,13 @@ class Repository(initialBranch: String = "master") {
     /**
      * List all commits.
      */
-    fun listCommits(): List<Commit> = head.commits.toList()
+    fun listCommits(): List<Commit> = commits.toList()
 
     /**
      * Find commit.
      */
-    fun findCommit(predicate: (Commit) -> Boolean): Commit? = head.commits.find(predicate)
+    fun findCommit(predicate: (Commit) -> Boolean): Commit? =
+        commits.find(predicate)
 
     /**
      * Dump repository objects
@@ -102,15 +63,14 @@ class Repository(initialBranch: String = "master") {
         val hash = tree.hash()
         val obj = findObject<Tree>(hash)
         if (obj != null) return obj
-        val newTree =
-            Tree(
-                tree.nodes.map { (name, node) ->
-                    when (node) {
-                        is Tree -> name to addTree(node)
-                        is Blob -> name to addObject(node)
-                    }
-                }.toMap(),
-            )
+        val newTree = Tree(
+            tree.nodes.map { (name, node) ->
+                when (node) {
+                    is Tree -> name to addTree(node)
+                    is Blob -> name to addObject(node)
+                }
+            }.toMap()
+        )
         objects[hash] = newTree
         return tree
     }
@@ -126,6 +86,5 @@ class Repository(initialBranch: String = "master") {
      */
     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")
+}

src/main/kotlin/tinyvm/Tree.kt

@@ -1,36 +1,13 @@
 package tinyvm
 
-/**
- * Tree nodes are either trees or blobs, represented by this sealed class.
- */
-sealed class Node(type: String) : Object(type)
+sealed class Node(type: String): Object(type)
 
-/**
- * A tree is a set of named nodes.
- */
 class Tree(val nodes: Map<String, Node>) : Node("tree") {
     // For simplicity just use the hex-formatted hash, not the actual value like git does.
     override val data: String
-        get() =
-            nodes.map { (name, node) ->
-                "${node.type} $name\u0000${node.hash()}"
-            }.sorted().joinToString()
-
-    override fun toString(): String =
-        "tree ${hash()}\n" +
-            nodes.map { (name, node) ->
-                when (node) {
-                    is Tree -> "+$name/\n"
-                    is Blob -> "+$name\n"
-                } + node.toString().insertLeftMargin()
-            }.sorted().joinToString("\n")
+        get() = nodes.map { (name, node) ->
+            "${node.type} $name\u0000${node.hash()}"
+        }.sorted().joinToString()
 }
 
-/**
- * A blob is a data container.
- */
-class Blob(override val data: String) : Node("blob") {
-    override fun toString(): String = "blob ${hash()}\n${data.insertLeftMargin()}"
-}
-
-private fun String.insertLeftMargin(): String = split('\n').joinToString("\n") { "| $it" }
+class Blob(override val data: String) : Node("blob")

src/test/kotlin/tinyvm/RepositoryTest.kt

@@ -6,60 +6,51 @@ import kotlin.test.assertEquals
 
 internal class RepositoryTest {
     private val repository = Repository()
-    private val commits =
-        listOf(
-            Commit(
-                tree = Tree(mapOf("test1.txt" to Blob("Hello World!"))),
-                author = Author("Gleb Koval", "gleb@koval.net"),
-                message = "Add test1.txt",
-                timestamp = Instant.ofEpochSecond(0),
-            ),
-            Commit(
-                tree =
-                    Tree(
+    private val commits = listOf(
+        Commit(
+            tree = Tree(mapOf("test1.txt" to Blob("Hello World!"))),
+            author = Author("Gleb Koval", "gleb@koval.net"),
+            message = "Add test1.txt",
+            timestamp = Instant.ofEpochSecond(0)
+        ), Commit(
+            tree = Tree(
+                mapOf(
+                    "dir1" to Tree(
                         mapOf(
-                            "dir2" to
-                                Tree(
-                                    mapOf(
-                                        "test1.txt" to Blob("This is a second file"),
-                                    ),
-                                ),
-                            "dir1" to
-                                Tree(
-                                    mapOf(
-                                        "test1.txt" to Blob("Hello World!"),
-                                    ),
-                                ),
-                        ),
+                            "test1.txt" to Blob("Hello World!")
+                        )
                     ),
-                author = Author("Gleb Koval", "gleb@koval.net"),
-                message = "Move test1.txt to dir1 and add dir2/test1.txt",
-                timestamp = Instant.ofEpochSecond(50),
-            ),
-            Commit(
-                tree =
-                    Tree(
+                    "dir2" to Tree(
                         mapOf(
-                            "dir1" to
-                                Tree(
-                                    mapOf(
-                                        "test1.txt" to Blob("Hello World!"),
-                                    ),
-                                ),
-                            "dir2" to
-                                Tree(
-                                    mapOf(
-                                        "test1.txt" to Blob("This is a second file"),
-                                    ),
-                                ),
-                            "README.md" to Blob("# This is a test repo!"),
-                        ),
-                    ),
-                author = Author("Gleb Koval", "gleb@koval.net"),
-                message = "Add README.md",
-                timestamp = Instant.ofEpochSecond(100),
+                            "test2.txt" to Blob("This is a second file")
+                        )
+                    )
+                )
             ),
+            author = Author("Gleb Koval", "gleb@koval.net"),
+            message = "Move test1.txt and add dir2/test2.txt",
+            timestamp = Instant.ofEpochSecond(50)
+        ), Commit(
+            tree = Tree(
+                mapOf(
+                    "dir1" to Tree(
+                        mapOf(
+                            "test1.txt" to Blob("Hello World!")
+                        )
+                    ),
+                    "dir2" to Tree(
+                        mapOf(
+                            "test2.txt" to Blob("This is a second file")
+                        )
+                    ),
+                    "README.md" to Blob("# This is a test repo!")
+                )
+            ),
+            author = Author("Gleb Koval", "gleb@koval.net"),
+            message = "Add README.md",
+            timestamp = Instant.ofEpochSecond(100)
         )
+    )
 
     @Test
     fun `can commit`() {
@@ -117,68 +108,4 @@ internal class RepositoryTest {
         assertEquals(committed, repository.findCommit { it.message.matches("Move.*".toRegex()) })
         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(
-            """
-            commit 804c6f0c66da0ea0eab8ac29f23a627e03a962b2
-            tree aaebbb258bce30749fc302cbd161b78462252a32
-            author Gleb Koval <gleb@koval.net>
-            timestamp 0
-            
-            Add test1.txt
-            """.trimIndent(),
-            commits[0].toString(),
-        )
-    }
-
-    @Test
-    fun `can display tree`() {
-        assertEquals(
-            """
-            tree 048b8e267dd7a6c5d4849d59f6ff82e6ae948f13
-            +dir1/
-            | tree aaebbb258bce30749fc302cbd161b78462252a32
-            | +test1.txt
-            | | blob c57eff55ebc0c54973903af5f72bac72762cf4f4
-            | | | Hello World!
-            +dir2/
-            | tree 0e14cbdba02924cd63a58c2492fc3dd05dc682bd
-            | +test1.txt
-            | | blob da3fcc31cbc16fcbb7526d68771f77e7e7f02fb1
-            | | | This is a second file
-            """.trimIndent(),
-            commits[1].tree.toString(),
-        )
-    }
 }