using the new function where mounting happens

Author: nikololiahim

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

@@ -1,33 +1,43 @@
 package org.polystat.cli
 
 import cats.effect.IO
-import cats.syntax.foldable.*
-import cats.syntax.traverse.*
+import cats.syntax.all.*
+import fs2.io.file.Path
 import io.circe.syntax.*
+import org.polystat.cli.util.InputUtils.*
 import org.polystat.odin.analysis.ASTAnalyzer
 import org.polystat.odin.analysis.EOOdinAnalyzer
+import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisResult
 import org.polystat.odin.parser.EoParser.sourceCodeEoParser
 import org.polystat.sarif.AggregatedSarifOutput
 import org.polystat.sarif.SarifOutput
-import fs2.io.file.Path
 
 import PolystatConfig.*
-import InputUtils.*
-import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisResult
 
 object EO:
 
   def analyze(cfg: ProcessedConfig): IO[Unit] =
-    def runAnalyzers(inputFiles: Vector[(Path, String)]) = inputFiles
-      .traverse { case (codePath, code) =>
-        for
-          _ <- IO.println(s"Analyzing $codePath...")
-          analyzed <- cfg.filteredAnalyzers.traverse(a =>
-            a.analyze(cfg.tempDir)(codePath)(code)
-              .handleError(e => OdinAnalysisResult.AnalyzerFailure(a.ruleId, e))
-          )
-        yield (codePath, analyzed)
-      }
+    def runAnalyzers(
+        inputFiles: Vector[(Path, String)]
+    ): IO[Vector[(Path, List[OdinAnalysisResult])]] =
+      inputFiles
+        .traverse { case (codePath, code) =>
+          for
+            _ <- IO.println(s"Analyzing $codePath...")
+            analyzed <- cfg.filteredAnalyzers.traverse(a =>
+              a.analyze(
+                tmpDir = cfg.tempDir,
+                // TODO: make sure cfg input is always converted to directory
+                pathToSrcRoot =
+                  cfg.input.asInstanceOf[Input.FromDirectory].path,
+                pathToCode = codePath,
+                code = code,
+              ).handleError(e =>
+                OdinAnalysisResult.AnalyzerFailure(a.ruleId, e)
+              )
+            )
+          yield (codePath, analyzed)
+        }
 
     def writeToDirs(
         analyzed: Vector[(Path, List[OdinAnalysisResult])]
@@ -42,7 +52,13 @@ object EO:
             ).json.toString
             cfg.output.dirs.traverse_(out =>
               val outPath =
-                out / "sarif" / codePath.replaceExt(".sarif.json")
+                codePath
+                  .mount(
+                    to = out / "sarif",
+                    relativelyTo =
+                      cfg.input.asInstanceOf[Input.FromDirectory].path,
+                  )
+                  .replaceExt(newExt = ".sarif.json")
               for
                 _ <- IO.println(s"Writing results to $outPath...")
                 _ <- writeOutputTo(outPath)(sarifJson)
@@ -63,17 +79,8 @@ object EO:
         }
       }
 
-    def pathToDisplay(relPath: Path) = cfg.input match
-      case Input.FromDirectory(dir) => dir / relPath
-      // TODO: account for other cases
-      // This should be the same pass that is created when running readCodeFromX
-      case _ => relPath
-
     for
       inputFiles <- readCodeFromInput(".eo", cfg.input).compile.toVector
-        .map(_.map { case (path, results) =>
-          (pathToDisplay(path), results)
-        })
       analyzed <- runAnalyzers(inputFiles)
       _ <- cfg.output.dirs.traverse_ { outDir =>
         for

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

@@ -1,23 +1,24 @@
 package org.polystat.cli
 
-import cats.effect.Sync
 import cats.effect.IO
+import cats.effect.Sync
+import com.jcabi.xml.XML
+import com.jcabi.xml.XMLDocument
 import fs2.io.file.Path
 import higherkindness.droste.data.Fix
+import org.cactoos.Func
+import org.cactoos.io.InputOf
+import org.cactoos.io.OutputTo
+import org.eolang.parser.Spy
+import org.eolang.parser.Syntax
+import org.eolang.parser.Xsline
+import org.polystat.cli.util.InputUtils.*
 import org.polystat.far.FaR
 import org.polystat.odin.analysis.ASTAnalyzer
 import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisResult
 import org.polystat.odin.core.ast.EOExpr
 import org.polystat.odin.core.ast.EOProg
-import org.eolang.parser.Syntax
-import org.eolang.parser.Xsline
-import org.eolang.parser.Spy
-import org.cactoos.io.OutputTo
-import org.cactoos.io.InputOf
-import org.cactoos.Func
-import com.jcabi.xml.XMLDocument
-import com.jcabi.xml.XML
-import org.polystat.cli.InputUtils.replaceExt
+
 import java.nio.file.Path as JPath
 import scala.jdk.CollectionConverters.*
 
@@ -41,16 +42,23 @@ object Far:
   ): IO[java.util.Collection[String]] =
     IO.delay(new FaR().errors(program(pathToXml), locator))
 
-  def analyze(ruleId: String)(pathToTmpDir: Path)(
-      pathToCode: Path
+  def analyze(
+      ruleId: String,
+      pathToSrcRoot: Path,
+      pathToTmpDir: Path,
+      pathToCode: Path,
   ): IO[OdinAnalysisResult] =
-    val codeFileName: Path = pathToCode.fileName
-    val codeFileNameNoExt: String =
-      codeFileName.toString.splitAt(codeFileName.toString.indexOf("."))._1
-    val pathToXml: JPath =
-      (pathToTmpDir / codeFileName.replaceExt(".xml")).toNioPath
+    val codeFileNameNoExt: String = pathToCode.filenameNoExt
+    val createPathToXml: IO[JPath] =
+      (pathToTmpDir / "xmir").createDirIfDoesntExist.map(tmp =>
+        pathToCode
+          .mount(to = tmp, relativelyTo = pathToSrcRoot)
+          .replaceExt(newExt = ".xml")
+          .toNioPath
+      )
 
     for
+      pathToXml <- createPathToXml
       // parse EO to XMIR
       _ <- IO.delay(
         new Syntax(

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

@@ -12,11 +12,11 @@ import org.http4s.client.middleware.FollowRedirect
 import org.http4s.ember.client.EmberClientBuilder
 import org.http4s.ember.core.h2.*
 import org.http4s.implicits.*
+import org.polystat.cli.BuildInfo
+import org.polystat.cli.util.InputUtils.*
 
 import sys.process.*
 import PolystatConfig.*
-import InputUtils.*
-import org.polystat.cli.BuildInfo
 
 object Java:
 
@@ -95,6 +95,7 @@ object Java:
       cfg: ProcessedConfig,
   ): IO[Unit] =
     for
+      dirForEO <- (cfg.tempDir / "eo").createDirIfDoesntExist
       _ <- cfg.input match // writing EO files to tempDir
         case Input.FromStdin =>
           for
@@ -107,24 +108,24 @@ object Java:
               j2eoVersion,
               j2eo,
               inputDir = stdinTmp,
-              outputDir = cfg.tempDir,
+              outputDir = dirForEO,
             )
           yield ()
         case Input.FromFile(path) =>
-          runJ2EO(j2eoVersion, j2eo, inputDir = path, outputDir = cfg.tempDir)
+          runJ2EO(j2eoVersion, j2eo, inputDir = path, outputDir = dirForEO)
         case Input.FromDirectory(path) =>
-          runJ2EO(j2eoVersion, j2eo, inputDir = path, outputDir = cfg.tempDir)
+          runJ2EO(j2eoVersion, j2eo, inputDir = path, 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.
       // The line below patches this issue by creating the temp directory if it was deleted by J2EO.
       _ <- Files[IO]
         .exists(cfg.tempDir)
         .ifM(
           ifTrue = IO.unit,
-          ifFalse = Files[IO].createDirectory(cfg.tempDir),
+          ifFalse = Files[IO].createDirectories(dirForEO),
         )
       _ <- EO.analyze(
-        cfg.copy(input = Input.FromDirectory(cfg.tempDir))
+        cfg.copy(input = Input.FromDirectory(dirForEO))
       )
     yield ()
 

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

@@ -4,31 +4,38 @@ import cats.effect.IO
 import cats.effect.IOApp
 import fs2.io.file.Files
 import fs2.io.file.Path
-import org.polystat.cli.InputUtils.*
 import org.polystat.cli.PolystatConfig.*
+import org.polystat.cli.util.InputUtils.*
 import org.polystat.py2eo.transpiler.Transpile
 
 object Python:
 
   def analyze(cfg: ProcessedConfig): IO[Unit] =
+    val dirForEO = cfg.tempDir / "eo"
     for
       _ <- readCodeFromInput(".py", cfg.input)
         .evalMap { case (path, code) =>
-          val fileName = path.fileName.toString
           for
             maybeCode <- IO(
-              Transpile(fileName.splitAt(fileName.indexOf("."))._1, code)
+              Transpile(path.filenameNoExt, code)
             )
+            pathToEOCode = path
+              .mount(
+                to = dirForEO,
+                // TODO: remove asInstanceOf
+                relativelyTo = cfg.input.asInstanceOf[Input.FromDirectory].path,
+              )
+              .replaceExt(newExt = ".eo")
             _ <- maybeCode match
               case Some(code) =>
-                writeOutputTo(cfg.tempDir / path.replaceExt(".eo"))(code)
+                writeOutputTo(pathToEOCode)(code)
               case None => IO.println(s"Couldn't analyze $path...")
           yield ()
           end for
         }
         .compile
         .drain
-      _ <- EO.analyze(cfg.copy(input = Input.FromDirectory(cfg.tempDir)))
+      _ <- EO.analyze(cfg.copy(input = Input.FromDirectory(dirForEO)))
     yield ()
 
 end Python