Add seamless support for using JSON5 in the config file (#47)

Co-authored-by: Lucas Nogueira <lucas@tauri.studio>

Author: lucasfernog

.changes/json5.md

@@ -0,0 +1,21 @@
+---
+"tauri": patch
+"tauri-build": patch
+"tauri-codegen": patch
+"tauri-macros": patch
+"tauri-utils": patch
+"cli.rs": patch
+---
+
+Adds support for using JSON5 format for the `tauri.conf.json` file, along with also supporting the `.json5` extension.
+
+Here is the logic flow that determines if JSON or JSON5 will be used to parse the config:
+
+1. Check if `tauri.conf.json` exists
+   a. Parse it with `serde_json`
+   b. Parse it with `json5` if `serde_json` fails
+   c. Return original `serde_json` error if all above steps failed
+2. Check if `tauri.conf.json5` exists
+   a. Parse it with `json5`
+   b. Return error if all above steps failed
+3. Return error if all above steps failed

core/tauri-build/Cargo.toml

@@ -20,13 +20,14 @@ rustdoc-args = [ "--cfg", "doc_cfg" ]
 anyhow = "1"
 quote = { version = "1", optional = true }
 tauri-codegen = { version = "1.0.0-beta.4", path = "../tauri-codegen", optional = true }
-serde_json = "1.0"
 tauri-utils = { version = "1.0.0-beta.0", path = "../tauri-utils", features = [ "build" ] }
 cargo_toml = "0.10"
+serde_json = "1"
 
 [target."cfg(windows)".dependencies]
 winres = "0.1"
 
 [features]
 codegen = [ "tauri-codegen", "quote" ]
 isolation = ["tauri-codegen/isolation", "tauri-utils/isolation"]
+config-json5 = [ "tauri-utils/config-json5" ]

core/tauri-build/src/codegen/context.rs

@@ -120,7 +120,7 @@ impl CodegenContext {
       )
     })?;
 
-    writeln!(&mut file, "{}", code).with_context(|| {
+    writeln!(file, "{}", code).with_context(|| {
       format!(
         "Unable to write tokenstream to out file during tauri-build {}",
         out.display()

core/tauri-build/src/lib.rs

@@ -109,13 +109,20 @@ pub fn build() {
 pub fn try_build(attributes: Attributes) -> Result<()> {
   use anyhow::anyhow;
   use cargo_toml::{Dependency, Manifest};
-  use std::fs::read_to_string;
   use tauri_utils::config::Config;
 
-  println!("cargo:rerun-if-changed=tauri.conf.json");
   println!("cargo:rerun-if-changed=src/Cargo.toml");
-
-  let config: Config = serde_json::from_str(&read_to_string("tauri.conf.json")?)?;
+  println!("cargo:rerun-if-changed=tauri.conf.json");
+  #[cfg(feature = "config-json5")]
+  println!("cargo:rerun-if-changed=tauri.conf.json5");
+
+  let config: Config = if let Ok(env) = std::env::var("TAURI_CONFIG") {
+    serde_json::from_str(&env)?
+  } else {
+    serde_json::from_value(tauri_utils::config::parse::read_from(
+      std::env::current_dir().unwrap(),
+    )?)?
+  };
 
   let mut manifest = Manifest::from_path("Cargo.toml")?;
   if let Some(tauri) = manifest.dependencies.remove("tauri") {

core/tauri-codegen/Cargo.toml

@@ -32,3 +32,4 @@ default = [ "compression" ]
 compression = [ "zstd", "tauri-utils/compression" ]
 isolation = ["tauri-utils/isolation"]
 shell-scope = []
+config-json5 = [ "tauri-utils/config-json5" ]

core/tauri-codegen/src/lib.rs

@@ -2,53 +2,41 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-pub use context::{context_codegen, ContextData};
+pub use self::context::{context_codegen, ContextData};
 use std::{
   borrow::Cow,
-  fs::File,
-  io::BufReader,
   path::{Path, PathBuf},
 };
-use tauri_utils::config::Config;
-use thiserror::Error;
+pub use tauri_utils::config::{parse::ConfigError, Config};
 
 mod context;
 pub mod embedded_assets;
 
-/// Represents all the errors that can happen while reading the config.
-#[derive(Debug, Error)]
+/// Represents all the errors that can happen while reading the config during codegen.
+#[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
-pub enum ConfigError {
+pub enum CodegenConfigError {
   #[error("unable to access current working directory: {0}")]
   CurrentDir(std::io::Error),
 
   // this error should be "impossible" because we use std::env::current_dir() - cover it anyways
   #[error("Tauri config file has no parent, this shouldn't be possible. file an issue on https://github.com/tauri-apps/tauri - target {0}")]
   Parent(PathBuf),
 
-  #[error("unable to parse inline TAURI_CONFIG env var: {0}")]
+  #[error("unable to parse inline JSON TAURI_CONFIG env var: {0}")]
   FormatInline(serde_json::Error),
 
-  #[error("unable to parse Tauri config file at {path} because {error}")]
-  Format {
-    path: PathBuf,
-    error: serde_json::Error,
-  },
-
-  #[error("unable to read Tauri config file at {path} because {error}")]
-  Io {
-    path: PathBuf,
-    error: std::io::Error,
-  },
+  #[error("{0}")]
+  ConfigError(#[from] ConfigError),
 }
 
 /// Get the [`Config`] from the `TAURI_CONFIG` environmental variable, or read from the passed path.
 ///
 /// If the passed path is relative, it should be relative to the current working directory of the
 /// compiling crate.
-pub fn get_config(path: &Path) -> Result<(Config, PathBuf), ConfigError> {
+pub fn get_config(path: &Path) -> Result<(Config, PathBuf), CodegenConfigError> {
   let path = if path.is_relative() {
-    let cwd = std::env::current_dir().map_err(ConfigError::CurrentDir)?;
+    let cwd = std::env::current_dir().map_err(CodegenConfigError::CurrentDir)?;
     Cow::Owned(cwd.join(path))
   } else {
     Cow::Borrowed(path)
@@ -59,27 +47,16 @@ pub fn get_config(path: &Path) -> Result<(Config, PathBuf), ConfigError> {
   // already unlikely unless the developer goes out of their way to run the cli on a different
   // project than the target crate.
   let config = if let Ok(env) = std::env::var("TAURI_CONFIG") {
-    serde_json::from_str(&env).map_err(ConfigError::FormatInline)?
+    serde_json::from_str(&env).map_err(CodegenConfigError::FormatInline)?
   } else {
-    File::open(&path)
-      .map_err(|error| ConfigError::Io {
-        path: path.clone().into_owned(),
-        error,
-      })
-      .map(BufReader::new)
-      .and_then(|file| {
-        serde_json::from_reader(file).map_err(|error| ConfigError::Format {
-          path: path.clone().into_owned(),
-          error,
-        })
-      })?
+    tauri_utils::config::parse(path.to_path_buf())?
   };
 
   // this should be impossible because of the use of `current_dir()` above, but handle it anyways
   let parent = path
     .parent()
     .map(ToOwned::to_owned)
-    .ok_or_else(|| ConfigError::Parent(path.into_owned()))?;
+    .ok_or_else(|| CodegenConfigError::Parent(path.into_owned()))?;
 
   Ok((config, parent))
 }

core/tauri-macros/Cargo.toml

@@ -21,9 +21,11 @@ quote = "1"
 syn = { version = "1", features = [ "full" ] }
 heck = "0.3"
 tauri-codegen = { version = "1.0.0-beta.4", default-features = false, path = "../tauri-codegen" }
+tauri-utils = { version = "1.0.0-beta.3", path = "../tauri-utils" }
 
 [features]
 custom-protocol = [ ]
 compression = [ "tauri-codegen/compression" ]
 isolation = ["tauri-codegen/isolation"]
 shell-scope = ["tauri-codegen/shell-scope"]
+config-json5 = [ "tauri-codegen/config-json5", "tauri-utils/config-json5" ]

core/tauri-macros/src/context.rs

@@ -11,6 +11,7 @@ use syn::{
   LitStr, PathArguments, PathSegment, Token,
 };
 use tauri_codegen::{context_codegen, get_config, ContextData};
+use tauri_utils::config::parse::does_supported_extension_exist;
 
 pub(crate) struct ContextItems {
   config_file: PathBuf,
@@ -35,7 +36,7 @@ impl Parse for ContextItems {
       VarError::NotUnicode(_) => "CARGO_MANIFEST_DIR env var contained invalid utf8".into(),
     })
     .and_then(|path| {
-      if path.exists() {
+      if does_supported_extension_exist(&path) {
         Ok(path)
       } else {
         Err(format!(

core/tauri-utils/Cargo.toml

@@ -31,6 +31,8 @@ ring = { version = "0.16", optional = true, features = ["std"] }
 once_cell = { version = "1.8", optional = true }
 serialize-to-javascript = { git = "https://github.com/chippers/serialize-to-javascript" }
 ctor = "0.1"
+json5 = { version = "0.4", optional = true }
+json-patch = "0.2"
 
 [target."cfg(target_os = \"linux\")".dependencies]
 heck = "0.4"
@@ -41,3 +43,4 @@ compression = [ "zstd" ]
 schema = ["schemars"]
 isolation = [ "aes-gcm", "ring", "once_cell" ]
 process-relaunch-dangerous-allow-symlink-macos = []
+config-json5 = [ "json5" ]

core/tauri-utils/src/config.rs

@@ -24,6 +24,11 @@ use url::Url;
 
 use std::{collections::HashMap, fmt, fs::read_to_string, path::PathBuf};
 
+/// Items to help with parsing content into a [`Config`].
+pub mod parse;
+
+pub use self::parse::parse;
+
 /// The window webview URL options.
 #[derive(PartialEq, Debug, Clone, Deserialize, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]