[Feat] Determine the format automatically for input files on the CLI

cli/tests/integration/inputs/mixed.json

@@ -0,0 +1,6 @@
+{
+  "extra": {
+    "subfield": "here",
+    "json": true
+  }
+}

cli/tests/integration/inputs/mixed.ncl

@@ -0,0 +1,3 @@
+{
+  extra.nickel = true,
+}

cli/tests/integration/inputs/mixed.toml

@@ -0,0 +1,5 @@
+foo = "hello"
+bar = 123
+
+[extra]
+toml = true

cli/tests/integration/inputs/mixed_contract.ncl

@@ -0,0 +1,10 @@
+{
+  bar | Number,
+  extra | {
+    nickel | Bool,
+    subfield | String,
+    toml | Bool,
+    json | Bool,
+  },
+  foo | String,
+}

cli/tests/integration/main.rs

@@ -1,5 +1,6 @@
 use std::{
     io::Write,
+    path::PathBuf,
     process::{Command, Stdio},
 };
 
@@ -73,3 +74,58 @@ fn automatic_color_on_non_tty() {
         );
     }
 }
+
+#[test]
+// This test didn't fit the snapshot test specification very well. While it can be encoded as
+// snapshot test, it didn't work on the CI (where the working directory doesn't seem to be properly
+// set for some reason), so we are using a manual test for now.
+fn merge_mixed_formats() {
+    let mut input_base_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    // We don't push "tests/integration/inputs" at once because that wouldn't work on Windows.
+    input_base_path.push("tests");
+    input_base_path.push("integration");
+    input_base_path.push("inputs");
+
+    let nickel_bin = env!("CARGO_BIN_EXE_nickel");
+
+    let nickel = Command::new(nickel_bin)
+        .arg("export")
+        .args([
+            input_base_path.join("mixed.ncl").into_os_string(),
+            input_base_path.join("mixed.json").into_os_string(),
+            input_base_path.join("mixed.toml").into_os_string(),
+        ])
+        .arg("--apply-contract")
+        .arg(input_base_path.join("mixed_contract.ncl").into_os_string())
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("Nickel should be runnable");
+
+    let output = nickel
+        .wait_with_output()
+        .expect("couldn't retrieve stdout handle to Nickel");
+
+    let stderr_output =
+        String::from_utf8(output.stderr).expect("The result of Nickel should be valid utf8");
+    let stdout_output =
+        String::from_utf8(output.stdout).expect("The result of Nickel should be valid utf8");
+
+    assert_eq!(stderr_output, "");
+    assert_eq!(
+        stdout_output,
+        "\
+{
+  \"bar\": 123,
+  \"extra\": {
+    \"json\": true,
+    \"nickel\": true,
+    \"subfield\": \"here\",
+    \"toml\": true
+  },
+  \"foo\": \"hello\"
+}
+"
+    );
+}

core/src/bytecode/pretty.rs

@@ -995,8 +995,10 @@ impl<'a> Pretty<'a, Allocator> for &Node<'_> {
                     allocator,
                     "import",
                     allocator.space(),
-                    allocator.as_string(path.to_string_lossy()).double_quotes(),
-                    if Some(*format) != InputFormat::from_path(std::path::Path::new(path)) {
+                    allocator
+                        .escaped_string(path.to_string_lossy().as_ref())
+                        .double_quotes(),
+                    if Some(*format) != InputFormat::from_path(path) {
                         docs![
                             allocator,
                             allocator.space(),

core/src/cache.rs

@@ -68,8 +68,8 @@ pub enum InputFormat {
 
 impl InputFormat {
     /// Returns an [InputFormat] based on the file extension of a path.
-    pub fn from_path(path: &Path) -> Option<InputFormat> {
-        match path.extension().and_then(OsStr::to_str) {
+    pub fn from_path(path: impl AsRef<Path>) -> Option<InputFormat> {
+        match path.as_ref().extension().and_then(OsStr::to_str) {
             Some("ncl") => Some(InputFormat::Nickel),
             Some("json") => Some(InputFormat::Json),
             Some("yaml") | Some("yml") => Some(InputFormat::Yaml),

core/src/parser/utils.rs

@@ -395,8 +395,7 @@ pub fn mk_import_based_on_filename(
     _span: RawSpan,
 ) -> Result<Node<'_>, ParseError> {
     let path = OsString::from(path);
-    let format: Option<InputFormat> =
-        InputFormat::from_path(std::path::Path::new(path.as_os_str()));
+    let format: Option<InputFormat> = InputFormat::from_path(&path);
 
     // Fall back to InputFormat::Nickel in case of unknown filename extension for backwards compatiblilty.
     let format = format.unwrap_or_default();

core/src/pretty.rs

@@ -1157,10 +1157,10 @@ impl<'a> Pretty<'a, Allocator> for &Term {
                     allocator,
                     "import",
                     allocator.space(),
-                    allocator.as_string(path.to_string_lossy()).double_quotes(),
-                    if Some(*format)
-                        != InputFormat::from_path(std::path::Path::new(path.as_os_str()))
-                    {
+                    allocator
+                        .escaped_string(path.to_string_lossy().as_ref())
+                        .double_quotes(),
+                    if Some(*format) != InputFormat::from_path(path) {
                         docs![
                             allocator,
                             allocator.space(),

core/src/program.rs

@@ -267,6 +267,10 @@ impl<EC: EvalCache> Program<EC> {
 
     /// Contructor that abstracts over the Input type (file, string, etc.). Used by
     /// the other constructors. Published for those that need abstraction over the kind of Input.
+    ///
+    /// The format of the input is Nickel by default. However, for [Input::Path]s, the format is
+    /// determined from the file extension. This is useful to merge Nickel and non-Nickel files, or
+    /// to apply extra contracts to non-Nickel configurations.
     pub fn new_from_input<T, S>(
         input: Input<T, S>,
         trace: impl Write + 'static,
@@ -280,7 +284,11 @@ impl<EC: EvalCache> Program<EC> {
         let mut cache = CacheHub::new();
 
         let main_id = match input {
-            Input::Path(path) => cache.sources.add_file(path, InputFormat::Nickel)?,
+            Input::Path(path) => {
+                let path = path.into();
+                let format = InputFormat::from_path(&path).unwrap_or_default();
+                cache.sources.add_file(path, format)?
+            }
             Input::Source(source, name) => {
                 let path = PathBuf::from(name.into());
                 cache
@@ -302,6 +310,10 @@ impl<EC: EvalCache> Program<EC> {
     /// Constructor that abstracts over an iterator of Inputs (file, strings,
     /// etc). Published for those that need abstraction over the kind of Input
     /// or want to mix multiple different kinds of Input.
+    ///
+    /// The format of each input is Nickel by default. However, for [Input::Path]s, the format is
+    /// determined from the file extension. This is useful to merge Nickel and non-Nickel files, or
+    /// to apply extra contracts to non-Nickel configurations.
     pub fn new_from_inputs<I, T, S>(
         inputs: I,
         trace: impl Write + 'static,
@@ -318,10 +330,12 @@ impl<EC: EvalCache> Program<EC> {
         let merge_term = inputs
             .into_iter()
             .map(|input| match input {
-                Input::Path(path) => RichTerm::from(Term::Import(Import::Path {
-                    path: path.into(),
-                    format: InputFormat::Nickel,
-                })),
+                Input::Path(path) => {
+                    let path = path.into();
+                    let format = InputFormat::from_path(&path).unwrap_or_default();
+
+                    RichTerm::from(Term::Import(Import::Path { path, format }))
+                }
                 Input::Source(source, name) => {
                     let path = PathBuf::from(name.into());
                     cache

flake.nix

@@ -190,9 +190,12 @@
           txtFilter = mkFilter ".*txt$";
           snapFilter = mkFilter ".*snap$";
           scmFilter = mkFilter ".*scm$";
-          mdFilter = mkFilter ".*md$"; # include markdown files for checking snippets in the documentation
+          # include markdown files for checking snippets in the documentation
+          mdFilter = mkFilter ".*md$";
           cxxFilter = mkFilter ".*(cc|hh)$";
-          importsFilter = mkFilter ".*/core/tests/integration/inputs/imports/imported/.*$"; # include all files that are imported in tests
+          # include all files that are used in tests
+          importsFilter = mkFilter ".*/core/tests/integration/inputs/imports/imported/.*$";
+          testsInputsFilter = mkFilter ".*/cli/tests/integration/inputs/.*$";
         in
         pkgs.lib.cleanSourceWith {
           src = pkgs.lib.cleanSource ./.;
@@ -210,6 +213,7 @@
               cxxFilter
               filterCargoSources
               importsFilter
+              testsInputsFilter
             ];
         };