--files -> --to

Author: nikololiahim

.polystat.conf

@@ -1,7 +1,11 @@
 polystat {
-    lang = eo
-    input = sandbox
-    outputTo = .
+    lang = java
+    input = sandbox_java
     tempDir = tmp
     outputFormats = [sarif]
+    outputs = {
+        console = true,
+        dirs = [out],
+        files = [./results/out.txt],
+    }
 }

README.md

@@ -10,7 +10,7 @@ Prints all the available config keys. The configuration file format is [HOCON](h
 
 Get the plain text console output from analyzing Java files. The Java files are in the directory `src/main/java`. 
 
-> `polystat eo --in tmp --sarif --files polystat_out`
+> `polystat eo --in tmp --sarif --to dir=polystat_out`
 
 Write the [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) JSON files to `polystat_out/sarif` from analysing the `tmp` directory with `.eo` files.
 
@@ -21,8 +21,22 @@ Write the [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.ht
 The description follows [this guide](https://en.wikipedia.org/wiki/Command-line_interface#Command_description_syntax).
 > Note: {a | b | c} means a set of _mutually-exclusive_ items.
 ```
-polystat {eo | python} [--tmp <path>] [--in <path>] [{--include <rule...> | --exclude <rule...>}] [--sarif] [--files [path]]
-polystat java [--j2eo <path>] [--tmp <path>] [--in <path>] [{--include <rule...> | --exclude <rule...>}] [--sarif] [--files <path>]
+polystat
+    {eo | python}
+    [--tmp <path>]
+    [--in <path>]
+    [{--include <rule...> | --exclude <rule...>}]
+    [--sarif]
+    [--to { console | dir=<path>| file=<path> }]...
+polystat
+    java
+    [--j2eo-version <string>]
+    [--j2eo <path>]
+    [--tmp <path>]
+    [--in <path>]
+    [{--include <rule...> | --exclude <rule...>}]
+    [--sarif]
+    [--to { console | dir=<path>| file=<path> }]...
 polystat [--version] [--help] [--config <path>]
 polystat list [--config | -c]
 ```
@@ -34,19 +48,24 @@ polystat list [--config | -c]
 
 ## Configuration options
 * `--include` and `--exclude` respectively define which rules should be included/excluded from the analysis run. These options are mutually exclusive, so specifying both should not be valid. If neither option is specified, all the available analyzers will be run. The list of available rule specifiers can be found via `polystat list` command.
-* `--j2eo` options allows users to specify the path to the j2eo executable jar. If it's not specified, it looks for one in the current working diretory. 
+* `--j2eo` option allows users to specify the path to the j2eo executable jar. If it's not specified, it looks for one in the current working diretory. 
 If it's not present in the current working directory, download one from Maven Central (for now, the version is hardcoded to be 0.4.0).
+* `--j2eo-version` option allows users to specify which version of `j2eo` should be downloaded.
 
 ## Output configuration
 * `--sarif` option means that the command will produce the output in the [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) format in addition to output in other formats (if any). 
-* `--files <path>` option specifies whether the output should be written to the output directory instead of writing it to the console.
-If the path is specified, the command will write the files to the given path. The path is assumed to be an empty directory. If it is not, its contents will be purged.
+* `--to { console | dir=<path>| file=<path> }` is a repeatable option that specifies where the output should be written. If this option is not specified, no output is produced. 
+* `--to dir=<path>` means that the files will be written to the given path. The path is assumed to be an empty directory. If it is not, its contents will be purged.
     * If an additional output format is specified (e.g. `--sarif`), then the files created by the analyzer will be written in the respective subdirectory. For example, in case of `--sarif`,  the SARIF files will be located in `path/sarif/`. The console output is not written anywhere. Therefore, if none of the output format options (e.g. `--sarif`) are specified, no files are produced. 
     * The output format options (e.g. `--sarif`) also determine the extension of the output files. In case of `--sarif` the extension would be `.sarif.json`.
     * If `--in` option specifies a directory, the structure of the output directory will be similar to the structure of the input directory. 
     * If `--in` specifies a single file, the file with the analysis output for this file will be written to the output directory. 
     * If `--in` is not specified, the generated file will be called `stdin` + the relevant extension. 
 
+* `--to file=<path>` means that the results of analysis for all the files will be written to the file at the given path. For example, for `--sarif` output format this will a JSON array of `sarif-log` objects.
+
+* `--to console` specifies whether the output should be written to console. The specification doesn't prevent the user from specifying multiple instances of this option. In this case, the output will be written to console as if just one instance of `--to console` was present. If it's not present the output is not written to console. 
+
 ## `polystat list`
 * If `--config` or `-c` is specified, prints to console the description of all the possible configuration keys for the HOCON config file. If not, prints the specifiers for all the available analyzer rules. 
 

sandbox_java/MutualRec.java

@@ -1,16 +1,19 @@
-class Base {
-    int f(int x) {
-        return x;
-    }
 
-    int g(int x) {
-        return f(x);
+class MutualRec {
+    class Base {
+        int f(int x) {
+            return x;
+        }
+
+        int g(int x) {
+            return f(x);
+        }
     }
-}
 
-class Derived extends Base {
-    @Override
-    int f(int x) {
-        return g(x);
+    class Derived extends Base {
+        @Override
+        int f(int x) {
+            return g(x);
+        }
     }
 }

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

@@ -26,16 +26,17 @@ object EO:
         for
           _ <- IO.println(s"Analyzing $codePath...")
           analyzed <- runAnalyzers(cfg.filteredAnalyzers)(code)
-          _ <- cfg.output match
-            case Output.ToConsole => IO.println(analyzed)
-            case Output.ToDirectory(out) =>
-              cfg.fmts.traverse_ { case OutputFormat.Sarif =>
-                val outPath =
-                  out / "sarif" / codePath.replaceExt(".sarif.json")
-                val sarifJson = SarifOutput(analyzed).json.toString
-                IO.println(s"Writing results to $outPath") *>
-                  writeOutputTo(outPath)(sarifJson)
-              }
+          _ <- if cfg.output.console then IO.println(analyzed) else IO.unit
+          _ <- cfg.fmts.traverse_ { case OutputFormat.Sarif =>
+            val sarifJson = SarifOutput(analyzed).json.toString
+            cfg.output.dirs.traverse_(out =>
+              val outPath =
+                out / "sarif" / codePath.replaceExt(".sarif.json")
+
+              IO.println(s"Writing results to $outPath") *>
+                writeOutputTo(outPath)(sarifJson)
+            )
+          }
         yield ()
       }
       .compile

src/main/scala/org/polystat/HoconConfig.scala

@@ -39,9 +39,16 @@ case class HoconConfig(path: Path):
     case None       => IO.pure(Input.FromStdin)
   }
   private val tmp = hocon(keys.tempDir).as[Path].option
-  private val outputTo = hocon(keys.outputTo).as[Path].option.map {
-    case Some(path) => Output.ToDirectory(path)
-    case None       => Output.ToConsole
+  private val outputsDirs =
+    hocon(keys.outputsDirs).as[List[Path]].default(List())
+  private val outputsFiles =
+    hocon(keys.outputsFiles).as[List[Path]].default(List())
+  private val outputsConsole =
+    hocon(keys.outputsConsole).as[Boolean].default(false)
+
+  private val outputs = (outputsDirs, outputsFiles, outputsConsole).parMapN {
+    case (dirs, files, console) =>
+      Output(dirs = dirs, files = files, console = console)
   }
   private val outputFormats =
     hocon(keys.outputFormats).as[List[OutputFormat]].default(List.empty)
@@ -53,8 +60,8 @@ case class HoconConfig(path: Path):
       .option
 
   val config: ConfigValue[IO, PolystatUsage.Analyze] =
-    (j2eo, inex, input, tmp, outputTo, outputFormats, lang).parMapN {
-      case (j2eo, inex, input, tmp, outputTo, outputFormats, lang) =>
+    (j2eo, inex, input, tmp, outputs, outputFormats, lang).parMapN {
+      case (j2eo, inex, input, tmp, outputs, outputFormats, lang) =>
         PolystatUsage.Analyze(
           language = lang match
             case Java(_) => Java(j2eo)
@@ -65,7 +72,7 @@ case class HoconConfig(path: Path):
             input = input,
             tmp = tmp,
             outputFormats = outputFormats,
-            output = outputTo,
+            output = outputs,
           ),
         )
     }
@@ -83,6 +90,9 @@ object HoconConfig:
     val includeRules = "includeRules"
     val excludeRules = "excludeRules"
     val j2eo = "j2eo"
+    val outputsConsole = "outputs.console"
+    val outputsDirs = "outputs.dirs"
+    val outputsFiles = "output.files"
     val explanation = s"""
                        |$toplevel.$inputLanguage
                        |    The type of input files which will be analyzed. This key must be present.
@@ -111,6 +121,13 @@ object HoconConfig:
                        |    If both are specified, $toplevel.$includeRules takes precedence. 
                        |    The list of available rule specifiers can be found by running:
                        |        polystat.jar list
+                       |$toplevel.$outputsConsole
+                       |    Produce console output?
+                       |$toplevel.$outputsDirs
+                       |    A list of directories to write files to.
+                       |$toplevel.$outputsFiles
+                       |    A list of files to write aggregated output to. 
+                       |
                        |""".stripMargin
   end keys
   extension (v: HoconConfigValue)
@@ -151,8 +168,16 @@ object HoconConfig:
       _.toNelString.map(Exclude(_))
     )
 
-  private given ConfigDecoder[HoconConfigValue, List[OutputFormat]] =
+  private given hocon2listFormat
+      : ConfigDecoder[HoconConfigValue, List[OutputFormat]] =
     ConfigDecoder[HoconConfigValue].mapOption(keys.outputFormats) {
       _.toListString.traverse(_.asOutputFormat)
     }
+
+  private given hocon2listPath: ConfigDecoder[HoconConfigValue, List[Path]] =
+    ConfigDecoder[HoconConfigValue].mapOption("paths") {
+      _.toListString.traverse(path =>
+        ConfigDecoder[String, Path].decode(key = None, path).toOption
+      )
+    }
 end HoconConfig

src/main/scala/org/polystat/PolystatConfig.scala

@@ -18,7 +18,7 @@ object PolystatConfig:
       output: Output,
   )
 
-  case class ProcessedConfig(
+  final case class ProcessedConfig(
       filteredAnalyzers: List[ASTAnalyzer[IO]],
       tempDir: IO[Path],
       input: Input,
@@ -51,9 +51,10 @@ object PolystatConfig:
   enum OutputFormat:
     case Sarif
 
-  enum Output:
-    case ToDirectory(path: Path)
-    case ToConsole
-  end Output
+  final case class Output(
+      dirs: List[Path],
+      files: List[Path],
+      console: Boolean,
+  )
 
 end PolystatConfig

src/main/scala/org/polystat/PolystatOpts.scala

@@ -9,39 +9,17 @@ import com.monovore.decline.Opts
 import fs2.io.file.Files
 import fs2.io.file.Path
 import org.polystat.PolystatConfig.*
-
+import com.monovore.decline.Argument
 import java.io.FileNotFoundException
 import java.nio.file.Path as JPath
+import cats.data.ValidatedNel
 
 import IncludeExclude.*
 import Validated.*
 import InputUtils.toInput
+import com.monovore.decline.Argument
 
-object PolystatOpts extends IOApp.Simple:
-
-  override def run: IO[Unit] =
-    val opts = Seq(
-      "--config",
-      "aboba",
-      "--version",
-
-      // "c++",
-      // "--in",
-      // "tmp",
-      // "--include",
-      // "1",
-      // "--include",
-      // "2",
-      // "--files",
-      // "sandbox"
-    )
-
-    polystat
-      .parse(opts)
-      .map(a => a.flatMap(IO.println))
-      .leftMap(IO.println)
-      .merge
-  end run
+object PolystatOpts:
 
   def polystat: Command[IO[PolystatUsage]] = Command(
     name = "polystat",
@@ -170,16 +148,52 @@ object PolystatOpts extends IOApp.Simple:
       sarif
     ).sequence.map(_.flattenOption)
 
-  // TODO: this doesn't really conform to spec,
-  //       because decline doesn't support optional arguments to options
-  //       https://github.com/bkirwi/decline/issues/350
+  private enum OutputArg:
+    case File(path: Path)
+    case Directory(path: Path)
+    case Console
+  end OutputArg
+
+  private given Argument[OutputArg] with
+    def read(string: String): ValidatedNel[String, OutputArg] =
+      val KVArg = "(.*)=(.*)".r
+      string match
+        case KVArg(key, value) =>
+          key match
+            case "dir" =>
+              Argument[JPath]
+                .read(value)
+                .map(path => OutputArg.Directory(Path.fromNioPath(path)))
+            case "file" =>
+              Argument[JPath]
+                .read(value)
+                .map(path => OutputArg.File(Path.fromNioPath(path)))
+            case other =>
+              Validated.invalidNel(s"Unknown key in `--to` option: $other")
+        case "console" => Validated.valid(OutputArg.Console)
+        case other     => Validated.invalidNel(s"Unknown argument: $string")
+      end match
+    end read
+    def defaultMetavar: String = "console | dir=<path> | file=<path>"
+  end given
+
   def files: Opts[Output] = Opts
-    .option[JPath](
-      long = "files",
+    .options[OutputArg](
+      long = "to",
       help = "Create output files in the specified path",
     )
-    .map(p => Output.ToDirectory(Path.fromNioPath(p)))
-    .orElse(Output.ToConsole.pure[Opts])
+    .orEmpty
+    .map(args =>
+      val initialState = Output(dirs = List(), files = List(), console = false)
+      args.foldLeft(initialState) {
+        case (acc, OutputArg.File(path)) =>
+          acc.copy(files = acc.files.prepended(path))
+        case (acc, OutputArg.Directory(path)) =>
+          acc.copy(dirs = acc.dirs.prepended(path))
+        case (acc, OutputArg.Console) =>
+          if acc.console then acc else acc.copy(console = true)
+      }
+    )
 
   def analyzerConfig: Opts[IO[AnalyzerConfig]] =
     (inex, in, tmp, outputFormats, files).mapN {