Reboot Project

junghoon-vans · junghoon-vans · commit 25cdb7d95259 · 2025-03-23T12:34:43.000+09:00
diff --git a/.gitignore b/.gitignore
@@ -22,3 +22,8 @@ intellij/out
 
 ### BSP ###
 .bsp/
+
+### Metals ###
+.metals/
+.bloop/
+project/**/metals.sbt
diff --git a/.jindo.yaml b/.jindo.yaml
@@ -0,0 +1,5 @@
+preCommit:
+  - id: scalafmt
+    dependencies:
+      - org.scalameta::scalafmt-cli:latest.release
+    main: org.scalafmt.cli.Cli
diff --git a/README.adoc b/README.adoc
diff --git a/README.md b/README.md
@@ -0,0 +1,31 @@
+# Jindo(珍島)
+
+Bringing git-hooks into JVM world 🐕
+
+Jindo is a lightweight, JVM-based Git hooks manager that simplifies your development workflow.
+It allows you to run JVM applications as Git hooks without external dependencies.
+
+## Why Jindo?
+
+While tools like pre-commit and husky are great, they often introduce complexity and additional dependencies to JVM projects. Here's why Jindo is different:
+
+### 🚀 Zero External Dependencies
+* Only requires JVM 8+
+* No need for Node.js, Python, or other runtimes
+* Minimal setup overhead
+
+### 🔧 Simple Yet Powerful Configuration
+* Easy-to-understand YAML configuration
+* Support for multiple repositories
+* Flexible hook management
+
+### 📦 Seamless JVM Integration
+* Direct access to Maven Central
+* Automatic dependency resolution via Coursier
+* Run any JVM-based tools (Java, Scala, Kotlin, etc.)
+
+### 🔒 Reliable and Consistent
+* Same JVM environment across all hooks
+* Predictable behavior in CI/CD
+* Better performance for JVM-based checks
+* Direct execution without wrappers
diff --git a/build.sbt b/build.sbt
@@ -1,7 +1,28 @@
+import sbt.Keys._
+import sbtassembly.MergeStrategy
+import sbtassembly.PathList
+
 ThisBuild / version := "0.1.0-SNAPSHOT"
 ThisBuild / scalaVersion := "2.13.12"
 
+lazy val commonSettings = Seq(
+  organization := "io.vanslog",
+  scalacOptions ++= Seq("-deprecation", "-feature", "-unchecked")
+)
+
 lazy val root = (project in file("."))
   .settings(
-    name := "jindo"
+    name := "jindo",
+    commonSettings,
+    libraryDependencies ++= Seq(
+      "io.circe" %% "circe-yaml" % "0.14.2",
+      "io.circe" %% "circe-generic" % "0.14.2",
+      "io.get-coursier" %% "coursier" % "2.1.7",
+      "com.github.scopt" %% "scopt" % "4.1.0",
+    ),
+    assembly / assemblyJarName := "jindo.jar",
+    assembly / assemblyMergeStrategy := {
+      case PathList("META-INF", xs @ _*) => MergeStrategy.discard
+      case _ => MergeStrategy.first
+    }
   )
diff --git a/project/plugins.sbt b/project/plugins.sbt
@@ -1 +1,2 @@
 addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.6")
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1")
diff --git a/src/main/scala/Main.scala b/src/main/scala/Main.scala
@@ -1,3 +1,19 @@
+import cli.Cli
+import command.{Command, CommandFactory, CommandType}
+
 object Main {
-  def main(args: Array[String]): Unit = {}
+  def main(args: Array[String]): Unit = {
+    Cli.parse(args) match {
+      case Some(config) =>
+        CommandType.fromString(config.command) match {
+          case Some(cmdType) =>
+            val cmd = CommandFactory.create(cmdType, config.projectRoot)
+            cmd.execute()
+          case None =>
+            Cli.showUsage()
+        }
+      case None =>
+        Cli.showUsage()
+    }
+  }
 }
diff --git a/src/main/scala/cli/Cli.scala b/src/main/scala/cli/Cli.scala
@@ -0,0 +1,34 @@
+package cli
+
+import scopt.OParser
+import java.nio.file.{Path, Paths}
+
+case class CliConfig(
+    command: String = "",
+    projectRoot: Path = Paths.get(scala.util.Properties.userDir)
+)
+
+object Cli {
+  private val builder = OParser.builder[CliConfig]
+  private val parser = {
+    import builder._
+    OParser.sequence(
+      programName("jindo"),
+      head("jindo", "0.1.0"),
+      cmd("install")
+        .action((_, c) => c.copy(command = "install"))
+        .text("Install git hooks based on .jindo.yaml configuration"),
+      cmd("run")
+        .action((_, c) => c.copy(command = "run"))
+        .text("Run git hooks")
+    )
+  }
+
+  def parse(args: Array[String]): Option[CliConfig] = {
+    OParser.parse(parser, args, CliConfig())
+  }
+
+  def showUsage(): Unit = {
+    System.err.println(OParser.usage(parser))
+  }
+}
diff --git a/src/main/scala/command/Command.scala b/src/main/scala/command/Command.scala
@@ -0,0 +1,31 @@
+package command
+
+import java.nio.file.Path
+import config.ConfigLoader
+import hook.HookManager
+import hook.HookExecutor
+
+sealed trait Command {
+  def execute(): Unit
+}
+
+case class InstallCommand(projectRoot: Path) extends Command {
+  def execute(): Unit = {
+    val configLoader = new ConfigLoader(projectRoot)
+    val config = configLoader.loadConfig()
+
+    val hookManager = new HookManager(projectRoot)
+    hookManager.installHooks(config)
+    println("Git hooks installed successfully")
+  }
+}
+
+case class RunCommand(projectRoot: Path) extends Command {
+  def execute(): Unit = {
+    val configLoader = new ConfigLoader(projectRoot)
+    val config = configLoader.loadConfig()
+
+    val hookExecutor = new HookExecutor(projectRoot)
+    hookExecutor.execute(config)
+  }
+}
diff --git a/src/main/scala/command/CommandFactory.scala b/src/main/scala/command/CommandFactory.scala
@@ -0,0 +1,10 @@
+package command
+
+import java.nio.file.Path
+
+object CommandFactory {
+  def create(cmdType: CommandType, projectRoot: Path): Command = cmdType match {
+    case CommandType.Install => InstallCommand(projectRoot)
+    case CommandType.Run     => RunCommand(projectRoot)
+  }
+}
diff --git a/src/main/scala/command/CommandType.scala b/src/main/scala/command/CommandType.scala
@@ -0,0 +1,14 @@
+package command
+
+sealed trait CommandType
+
+object CommandType {
+  case object Install extends CommandType
+  case object Run extends CommandType
+
+  def fromString(cmd: String): Option[CommandType] = cmd match {
+    case "install" => Some(Install)
+    case "run"     => Some(Run)
+    case _         => None
+  }
+}
diff --git a/src/main/scala/config/Config.scala b/src/main/scala/config/Config.scala
@@ -0,0 +1,36 @@
+package config
+
+import io.circe.{Decoder, DecodingFailure}
+import io.circe.generic.semiauto._
+import hook.{Hook, SystemHook, JvmHook}
+
+/** Configuration for git hooks */
+case class Config(
+    preCommit: Option[List[Hook]] = None
+)
+
+object Config {
+  implicit val hookDecoder: Decoder[Hook] = (c: io.circe.HCursor) => {
+    for {
+      id <- c.downField("id").as[Option[String]]
+      args <- c.getOrElse[List[String]]("args")(List.empty)
+      command <- c.downField("command").as[Option[String]]
+      mainClass <- c.downField("main").as[Option[String]]
+      repositories <- c.downField("repositories").as[Option[List[String]]]
+      dependencies <- c.downField("dependencies").as[Option[List[String]]]
+    } yield {
+      (command, mainClass) match {
+        case (Some(cmd), None) => SystemHook(id, args, cmd)
+        case (None, Some(main)) =>
+          JvmHook(id, args, main, repositories, dependencies)
+        case _ =>
+          throw DecodingFailure(
+            "Either 'command' or 'main' must be specified",
+            c.history
+          )
+      }
+    }
+  }
+
+  implicit val configDecoder: Decoder[Config] = deriveDecoder[Config]
+}
diff --git a/src/main/scala/config/ConfigLoader.scala b/src/main/scala/config/ConfigLoader.scala
@@ -0,0 +1,29 @@
+package config
+
+import io.circe.yaml.parser
+import java.io.InputStreamReader
+import java.nio.file.{Files, Path}
+
+class ConfigLoader(projectRoot: Path) {
+  def loadConfig(): Config = {
+    val configPath = projectRoot.resolve(".jindo.yaml")
+    if (!Files.exists(configPath)) {
+      throw new IllegalStateException(".jindo.yaml not found in project root")
+    }
+
+    val configStream = Files.newInputStream(configPath)
+    val yamlJson = parser.parse(new InputStreamReader(configStream))
+
+    yamlJson match {
+      case Right(json) =>
+        json.as[Config] match {
+          case Right(config) => config
+          case Left(error) =>
+            throw new IllegalArgumentException(
+              s"Invalid configuration: ${error.getMessage}"
+            )
+        }
+      case Left(error) => throw error
+    }
+  }
+}
diff --git a/src/main/scala/hook/Hook.scala b/src/main/scala/hook/Hook.scala
@@ -0,0 +1,20 @@
+package hook
+
+sealed trait Hook {
+  def id: Option[String]
+  def args: List[String]
+}
+
+case class JvmHook(
+    id: Option[String],
+    args: List[String],
+    mainClass: String,
+    repositories: Option[List[String]],
+    dependencies: Option[List[String]]
+) extends Hook
+
+case class SystemHook(
+    id: Option[String],
+    args: List[String],
+    command: String
+) extends Hook
diff --git a/src/main/scala/hook/HookExecutor.scala b/src/main/scala/hook/HookExecutor.scala
@@ -0,0 +1,83 @@
+package hook
+
+import coursier._
+import coursier.core.Authentication
+import coursier.cache.FileCache
+import coursier.parse.DependencyParser
+
+import java.io.File
+import java.nio.file.{Files, Path, Paths}
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+import scala.concurrent.Await
+import config.Config
+
+/** Executes git hooks with dependency resolution */
+class HookExecutor(projectRoot: Path) {
+  private val cache = FileCache()
+
+  /** Execute a hook
+    *
+    * @param hook
+    *   the hook to execute
+    * @return
+    *   true if the hook execution was successful
+    */
+  def execute(config: Config): Unit = {
+    config.preCommit.foreach { hooks =>
+      hooks.foreach { hook =>
+        val success = executeHook(hook)
+        if (!success) {
+          System.exit(1)
+        }
+      }
+    }
+  }
+
+  private def executeHook(hook: Hook): Boolean = hook match {
+    case jvm: JvmHook    => executeJvmHook(jvm)
+    case sys: SystemHook => executeSystemHook(sys)
+  }
+
+  private def executeJvmHook(hook: JvmHook): Boolean = {
+    val repositories = hook.repositories
+      .map(_.map(MavenRepository(_)))
+      .getOrElse(Seq.empty)
+
+    val dependencies = hook.dependencies
+      .map(
+        _.flatMap(dep =>
+          DependencyParser.dependency(dep, defaultScalaVersion = "2.13").toSeq
+        )
+      )
+      .getOrElse(Seq.empty)
+
+    val fetch = Fetch()
+      .addDependencies(dependencies: _*)
+      .addRepositories(repositories: _*)
+
+    val files = Await.result(
+      fetch.future(),
+      1.minute
+    )
+
+    val classpath = files.map(_.getAbsolutePath).mkString(File.pathSeparator)
+    val process = new ProcessBuilder(
+      (Seq("java", "-cp", classpath, hook.mainClass) ++ hook.args): _*
+    )
+      .directory(projectRoot.toFile)
+      .inheritIO()
+      .start()
+
+    process.waitFor() == 0
+  }
+
+  private def executeSystemHook(hook: SystemHook): Boolean = {
+    val process = new ProcessBuilder((hook.command +: hook.args): _*)
+      .directory(projectRoot.toFile)
+      .inheritIO()
+      .start()
+
+    process.waitFor() == 0
+  }
+}
diff --git a/src/main/scala/hook/HookManager.scala b/src/main/scala/hook/HookManager.scala

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.6")`
	`2`	`+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1")`