Implement passing to-jelly options from a file

src/main/scala/eu/neverblink/jelly/cli/command/rdf/RdfToJelly.scala

@@ -10,12 +10,12 @@ import eu.neverblink.jelly.convert.jena.JenaConverterFactory
 import eu.neverblink.jelly.convert.jena.riot.{JellyFormatVariant, JellyLanguage, JellyStreamWriter}
 import eu.neverblink.jelly.core.{JellyOptions, RdfProtoDeserializationError}
 import eu.neverblink.jelly.core.proto.google.v1 as google
-import eu.neverblink.jelly.core.proto.v1.{LogicalStreamType, PhysicalStreamType, RdfStreamOptions}
+import eu.neverblink.jelly.core.proto.v1.*
 import org.apache.jena.riot.lang.LabelToNode
 import org.apache.jena.riot.system.StreamRDFWriter
 import org.apache.jena.riot.{Lang, RDFParser, RIOT}
 
-import java.io.{BufferedReader, InputStream, InputStreamReader, OutputStream}
+import java.io.{BufferedReader, FileInputStream, InputStream, InputStreamReader, OutputStream}
 import scala.util.Using
 
 object RdfToJellyPrint extends RdfCommandPrintUtil[RdfFormat.Readable]:
@@ -45,6 +45,10 @@ case class RdfToJellyOptions(
     @ExtraName("in-format") inputFormat: Option[String] = None,
     @Recurse
     jellySerializationOptions: RdfJellySerializationOptions = RdfJellySerializationOptions(),
+    @HelpMessage(
+      "Jelly file to load and copy serialization options from.",
+    )
+    optionsFrom: Option[String] = None,
     @HelpMessage(
       "Target number of rows per frame – the writer may slightly exceed that. Default: 256",
     )
@@ -72,8 +76,18 @@ object RdfToJelly extends RdfSerDesCommand[RdfToJellyOptions, RdfFormat.Readable
   val defaultAction: (InputStream, OutputStream) => Unit =
     langToJelly(RdfFormat.NQuads.jenaLang, _, _)
 
+  def loadOptionsFromFile(filename: String): RdfStreamOptions =
+    val inputStream = new FileInputStream(filename)
+    val frame = Using(inputStream) { content =>
+      RdfStreamFrame.parseDelimitedFrom(content)
+    }
+    frame.get.getRows.iterator().next().getOptions
+
   override def doRun(options: RdfToJellyOptions, remainingArgs: RemainingArgs): Unit =
     // Infer before touching options
+    options.optionsFrom.map(loadOptionsFromFile).foreach(
+      options.jellySerializationOptions.setOptions,
+    )
     options.jellySerializationOptions.inferGeneralized(
       options.inputFormat,
       remainingArgs.remaining.headOption,

src/main/scala/eu/neverblink/jelly/cli/command/rdf/util/RdfJellySerializationOptions.scala

@@ -41,8 +41,13 @@ case class RdfJellySerializationOptions(
     `opt.logicalType`: Option[String] = None,
 ):
   private object inferred:
+    var options: Option[RdfStreamOptions] = None
     var generalized: Boolean = false
 
+  def setOptions(rdfStreamOptions: RdfStreamOptions): Unit = inferred.options = Some(
+    rdfStreamOptions,
+  )
+
   def inferGeneralized(inputFormat: Option[String], filename: Option[String]): Unit =
     val explicitFormat = inputFormat.flatMap(RdfFormat.find)
     val implicitFormat = filename.flatMap(RdfFormat.inferFormat)
@@ -52,7 +57,7 @@ case class RdfJellySerializationOptions(
       case _ => false
     }
 
-  lazy val asRdfStreamOptions: RdfStreamOptions =
+  private def makeStreamOptions(): RdfStreamOptions =
     val logicalIri = `opt.logicalType`
       .map(_.trim).filter(_.nonEmpty)
       .map {
@@ -92,3 +97,5 @@ case class RdfJellySerializationOptions(
       .setMaxDatatypeTableSize(`opt.maxDatatypeTableSize`)
       .setPhysicalType(physicalType)
       .setLogicalType(logicalType.getOrElse(LogicalStreamType.UNSPECIFIED))
+
+  lazy val asRdfStreamOptions: RdfStreamOptions = inferred.options.getOrElse(makeStreamOptions())

src/test/scala/eu/neverblink/jelly/cli/command/rdf/RdfToJellySpec.scala

@@ -454,6 +454,31 @@ class RdfToJellySpec extends AnyWordSpec with TestFixtureHelper with Matchers:
           },
           jenaLang = RDFLanguages.NTRIPLES,
         )
+
+        "loading options from another file" in withSpecificJellyFile(
+          optionsFile =>
+            withFullJenaFile(
+              jenaFile => {
+                RdfToJelly.runTestCommand(
+                  List(
+                    "rdf",
+                    "to-jelly",
+                    "--options-from",
+                    optionsFile,
+                    jenaFile,
+                  ),
+                )
+                val frames = readJellyFile(new FileInputStream(optionsFile))
+                val opts = frames.head.getRows.asScala.head.getOptions
+                val newFrames = readJellyFile(new ByteArrayInputStream(RdfToJelly.getOutBytes))
+                val newOpts = newFrames.head.getRows.asScala.head.getOptions
+                opts should equal(newOpts)
+
+              },
+              jenaLang = RDFLanguages.NTRIPLES,
+            ),
+          fileName = "options.jelly",
+        )
       }
       "Turtle" in {
         val input = DataGenHelper.generateJenaInputStream(testCardinality, RDFLanguages.TURTLE)