refactored most usages of unsafeToX

Author: nikololiahim

src/main/scala/org/polystat/cli/EO.scala

@@ -50,14 +50,15 @@ object EO:
               results,
             ).json.toString
             cfg.output.dirs.traverse_(out =>
-              val outPath =
-                codePath
-                  .mount(
-                    to = (out / "sarif").unsafeToDirectory,
-                    relativelyTo = cfg.input,
-                  )
-                  .replaceExt(newExt = ".sarif.json")
               for
+                sarifDir <- (out / "sarif").createDirIfDoesntExist
+                outPath =
+                  codePath
+                    .mount(
+                      to = sarifDir,
+                      relativelyTo = cfg.input,
+                    )
+                    .replaceExt(newExt = ".sarif.json")
                 _ <- IO.println(s"Writing results to $outPath...")
                 _ <- writeOutputTo(outPath)(sarifJson)
               yield ()

src/main/scala/org/polystat/cli/Far.scala

@@ -51,7 +51,7 @@ object Far:
   ): IO[OdinAnalysisResult] =
     val codeFileNameNoExt: String = pathToCode.filenameNoExt
     val createPathToXml: IO[JPath] =
-      (pathToTmpDir / "xmir").unsafeToDirectory.createDirIfDoesntExist.map(
+      (pathToTmpDir / "xmir").createDirIfDoesntExist.map(
         tmp =>
           pathToCode
             .mount(to = tmp, relativelyTo = pathToSrcRoot)

src/main/scala/org/polystat/cli/Java.scala

@@ -91,7 +91,7 @@ object Java:
       cfg: ProcessedConfig,
   ): IO[Unit] =
     for
-      dirForEO <- (cfg.tempDir / "eo").unsafeToDirectory.createDirIfDoesntExist
+      dirForEO <- (cfg.tempDir / "eo").createDirIfDoesntExist
       _ <- runJ2EO(j2eoVersion, j2eo, input = cfg.input, outputDir = dirForEO)
       // J2EO deletes the tmp directory when there are no files to analyze
       // This causes the subsequent call to EO.analyze to fail, because there is no temp directory.

src/main/scala/org/polystat/cli/Main.scala

@@ -141,10 +141,10 @@ object Main extends IOApp:
               case Input.FromFile(file) =>
                 for
                   singleFileTmpDir <-
-                    (tempDir / "singleFile").unsafeToDirectory.createDirIfDoesntExist
+                    (tempDir / "singleFile").createDirIfDoesntExist
                   singleFileTmpPath =
-                    (singleFileTmpDir / (file.filenameNoExt + ext)).unsafeToFile
-                  _ <- singleFileTmpPath.unsafeToFile.createFileIfDoesntExist
+                    singleFileTmpDir / (file.filenameNoExt + ext)
+                  _ <- singleFileTmpPath.createFileIfDoesntExist
                   _ <- readCodeFromFile(ext, file)
                     .map(_._2)
                     .through(fs2.text.utf8.encode)
@@ -155,9 +155,8 @@ object Main extends IOApp:
               case Input.FromStdin =>
                 for
                   stdinTmpDir <-
-                    (tempDir / "stdin").unsafeToDirectory.createDirIfDoesntExist
-                  stdinTmpFilePath =
-                    (stdinTmpDir / ("stdin" + ext)).unsafeToFile
+                    (tempDir / "stdin").createDirIfDoesntExist
+                  stdinTmpFilePath = stdinTmpDir / ("stdin" + ext)
                   _ <- stdinTmpFilePath.createFileIfDoesntExist
                   _ <-
                     readCodeFromStdin

src/main/scala/org/polystat/cli/Python.scala

@@ -11,8 +11,8 @@ import org.polystat.py2eo.transpiler.Transpile
 object Python:
 
   def analyze(cfg: ProcessedConfig): IO[Unit] =
-    val dirForEO = (cfg.tempDir / "eo").unsafeToDirectory
     for
+      dirForEO <- (cfg.tempDir / "eo").createDirIfDoesntExist
       _ <- readCodeFromDir(".py", cfg.input)
         .evalMap { case (path, code) =>
           for

src/main/scala/org/polystat/cli/util/FileTypes.scala

@@ -9,6 +9,7 @@ object FileTypes:
       private[FileTypes] val underlying: Path
   ):
     override def toString = underlying.toString
+    def toPath: Path = underlying
 
   given Conversion[Directory, Path] = _.underlying
   object Directory:
@@ -30,25 +31,17 @@ object FileTypes:
     def fromPathUnsafe(path: Path): Directory = Directory(path)
 
   extension (dir: Directory)
-    def createDirIfDoesntExist: IO[Directory] =
-      Files[IO]
-        .exists(dir)
-        .ifM(
-          ifTrue = IO.pure(dir),
-          ifFalse = Files[IO].createDirectories(dir).as(dir),
-        )
-
     def clean: IO[Directory] =
       for
-        _ <- Files[IO].deleteRecursively(dir)
-        _ <- Files[IO].createDirectory(dir)
+        _ <- Files[IO].deleteRecursively(dir.toPath)
+        _ <- Files[IO].createDirectory(dir.toPath)
       yield dir
 
   class File private[FileTypes] (private[FileTypes] val underlying: Path):
     override def toString(): String = underlying.toString
+    def toPath = underlying
 
   given Conversion[File, Path] = _.underlying
-
   object File:
     def fromPath(path: Path): IO[Option[File]] =
       Files[IO]
@@ -68,15 +61,8 @@ object FileTypes:
     def fromPathUnsafe(path: Path): File = File(path)
 
   extension (file: File)
-    def createFileIfDoesntExist: IO[File] =
-      file.parent match
-        case Some(parent) =>
-          (Files[IO].createDirectories(parent) *> Files[IO].createFile(file))
-            .as(file)
-        case None => Files[IO].createFile(file).as(file)
-
     def filenameNoExt: String =
-      val fileName = file.fileName.toString
+      val fileName = file.toPath.fileName.toString
       fileName.splitAt(fileName.indexOf("."))._1
 
     def replaceExt(newExt: String): File =
@@ -90,5 +76,6 @@ object FileTypes:
 
     def mount(to: Directory, relativelyTo: Directory): File =
       val relativePath =
-        relativelyTo.absolute.normalize.relativize(file.absolute.normalize)
-      File.fromPathUnsafe(to.normalize / relativePath)
+        relativelyTo.toPath.absolute.normalize
+          .relativize(file.toPath.absolute.normalize)
+      File.fromPathUnsafe(to.toPath.normalize / relativePath)

src/main/scala/org/polystat/cli/util/InputUtils.scala

@@ -16,6 +16,25 @@ import java.io.FileNotFoundException
 object InputUtils:
 
   extension (path: Path)
+    def createDirIfDoesntExist: IO[Directory] =
+      Directory.fromPath(path).flatMap {
+        case Some(dir) => IO.pure(dir)
+        case None =>
+          Files[IO].createDirectories(path).as(path.unsafeToDirectory)
+      }
+
+    def createFileIfDoesntExist: IO[File] =
+      File.fromPath(path).flatMap {
+        case Some(file) => IO.pure(file)
+        case None =>
+          path.parent match
+            case Some(parent) =>
+              (Files[IO].createDirectories(parent) *> Files[IO]
+                .createFile(path))
+                .as(path.unsafeToFile)
+            case None => Files[IO].createFile(path).as(path.unsafeToFile)
+      }
+
     def toInput: IO[Input] =
       Directory.fromPath(path).flatMap {
         case Some(dir) => IO.pure(Input.FromDirectory(dir))
@@ -49,27 +68,18 @@ object InputUtils:
   def readCodeFromDir(ext: String, dir: Directory): Stream[IO, (File, String)] =
     Files[IO]
       .walk(dir)
-      .filter(_.extName.endsWith(ext))
+      .evalMapFilter(path =>
+        File.fromPath(path).map(_.filter(_.extName.endsWith(ext)))
+      )
       .flatMap(path =>
         Files[IO]
           .readAll(path)
           .through(utf8.decode)
-          .map(code => (path.unsafeToFile, code))
+          .map(code => (path, code))
       )
 
   def readCodeFromStdin: Stream[IO, String] = stdinUtf8[IO](4096).bufferAll
 
-  def readCodeFromInput(ext: String, input: Input): Stream[IO, (File, String)] =
-    input match
-      case Input.FromFile(path) =>
-        readCodeFromFile(ext = ext, file = path)
-      case Input.FromDirectory(path) =>
-        readCodeFromDir(ext = ext, dir = path)
-      case Input.FromStdin =>
-        readCodeFromStdin.map(code =>
-          (Path("stdin" + ext).unsafeToFile, "\n" + code + "\n")
-        )
-
   def readConfigFromFile(path: File): IO[PolystatUsage.Analyze] =
     HoconConfig(path).config.load