feat: clean on build_metadata change

Author: Bushuo

rewatch/src/build_metadata.rs

@@ -0,0 +1,68 @@
+use std::{
+    fs,
+    hash::{DefaultHasher, Hash, Hasher},
+    path::Path,
+};
+
+use crate::{config::Config, helpers, project_context::ProjectContext};
+
+pub struct BuildMetadata {
+    pub version: String,
+    pub config_hash: String,
+}
+
+impl BuildMetadata {
+    pub fn new(version: &str, config: &Config) -> Self {
+        let mut default_hasher = DefaultHasher::new();
+        config.hash(&mut default_hasher);
+        let config_hash = default_hasher.finish().to_string();
+        Self {
+            version: version.to_string(),
+            config_hash,
+        }
+    }
+}
+
+const BUILD_METADATA_FILE_NAME: &str = ".build-metadata";
+
+pub fn read_build_metadata(path: &Path) -> Option<BuildMetadata> {
+    let file_path = path.join(BUILD_METADATA_FILE_NAME);
+    let file_content = fs::read_to_string(file_path).ok()?;
+    let file_content = file_content.trim();
+
+    let mut lines = file_content.lines();
+    let version = lines.next()?.to_owned();
+    let config_hash = lines.next()?.to_owned();
+
+    Some(BuildMetadata { version, config_hash })
+}
+
+pub fn current_build_metadata(path: &Path, version: &str) -> BuildMetadata {
+    let config = helpers::get_nearest_config(&path).expect("Couldn't find package root");
+    let project_context = ProjectContext::new(&config).expect("Couldn't create project context");
+
+    BuildMetadata::new(version, project_context.get_root_config())
+}
+
+pub fn is_build_metadata_different(
+    last_build_metadata: Option<&BuildMetadata>,
+    current_build_metadata: &BuildMetadata,
+) -> bool {
+    match last_build_metadata {
+        Some(last_metadata) => {
+            last_metadata.version != current_build_metadata.version
+                || last_metadata.config_hash != current_build_metadata.config_hash
+        }
+        None => true,
+    }
+}
+
+pub fn write_build_metadata(path: &Path, build_metadata: &BuildMetadata) {
+    let file_path = path.join(BUILD_METADATA_FILE_NAME);
+    let mut file_content = String::from("");
+
+    file_content.push_str(&format!("{}\n", build_metadata.version));
+    file_content.push_str(&format!("{}\n", build_metadata.config_hash));
+
+    fs::write(file_path, file_content).unwrap();
+}

rewatch/src/config.rs

@@ -6,7 +6,7 @@ use serde::Deserialize;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Hash)]
 #[serde(untagged)]
 pub enum OneOrMore<T> {
     Multiple(Vec<T>),
@@ -141,7 +141,7 @@ impl Source {
 
 impl Eq for Source {}
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Hash)]
 pub struct PackageSpec {
     pub module: String,
     #[serde(rename = "in-source", default = "default_true")]
@@ -167,42 +167,42 @@ impl PackageSpec {
     }
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Hash)]
 #[serde(untagged)]
 pub enum Error {
     Catchall(bool),
     Qualified(String),
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Hash)]
 pub struct Warnings {
     pub number: Option<String>,
     pub error: Option<Error>,
 }
 
-#[derive(Deserialize, Debug, Clone)]
+#[derive(Deserialize, Debug, Clone, Hash)]
 #[serde(untagged)]
 pub enum NamespaceConfig {
     Bool(bool),
     String(String),
 }
 
-#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
+#[derive(Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
 #[serde(rename_all = "camelCase")]
 pub enum JsxMode {
     Classic,
     Automatic,
 }
 
-#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
+#[derive(Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
 #[serde(rename_all = "camelCase")]
 #[serde(untagged)]
 pub enum JsxModule {
     React,
     Other(String),
 }
 
-#[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
+#[derive(Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
 pub struct JsxSpecs {
     pub version: Option<i32>,
     pub module: Option<JsxModule>,
@@ -215,7 +215,7 @@ pub struct JsxSpecs {
 /// We do not care about the internal structure because the gentype config is loaded by bsc.
 pub type GenTypeConfig = serde_json::Value;
 
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Hash)]
 pub enum DeprecationWarning {
     BsDependencies,
     BsDevDependencies,
@@ -224,7 +224,7 @@ pub enum DeprecationWarning {
 
 /// # rescript.json representation
 /// This is tricky, there is a lot of ambiguity. This is probably incomplete.
-#[derive(Deserialize, Debug, Clone, Default)]
+#[derive(Deserialize, Debug, Clone, Hash, Default)]
 pub struct Config {
     pub name: String,
     // In the case of monorepos, the root source won't necessarily have to have sources. It can

rewatch/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod build;
+pub mod build_metadata;
 pub mod cli;
 pub mod cmd;
 pub mod config;

rewatch/src/main.rs

@@ -1,11 +1,13 @@
 use anyhow::Result;
-use clap::Parser;
+use clap::{CommandFactory, Parser};
 use log::LevelFilter;
 use std::{io::Write, path::Path};
 
-use rescript::{build, cli, cmd, format, lock, watcher};
+use rescript::{build, build_metadata, cli, cmd, format, lock, watcher};
 
 fn main() -> Result<()> {
+    let cli_as_command = cli::Cli::command();
+    let version = cli_as_command.get_version().expect("version is set");
     let args = cli::Cli::parse();
 
     let log_level_filter = args.verbose.log_level_filter();
@@ -37,6 +39,21 @@ fn main() -> Result<()> {
         cli::Command::Build(build_args) => {
             let _lock = get_lock(&build_args.folder);
 
+            if is_clean_build_needed(&build_args.folder, version) {
+                match build::clean::clean(
+                    &build_args.folder,
+                    show_progress,
+                    *build_args.snapshot_output,
+                    *build_args.dev,
+                ) {
+                    Ok(_) => {}
+                    Err(e) => {
+                        println!("{e}");
+                        std::process::exit(1);
+                    }
+                }
+            }
+
             match build::build(
                 &build_args.filter,
                 &build_args.folder,
@@ -54,24 +71,53 @@ fn main() -> Result<()> {
                     if let Some(args_after_build) = (*build_args.after_build).clone() {
                         cmd::run(args_after_build)
                     }
+                    build_metadata::write_build_metadata(
+                        &build_args.folder.join("lib"),
+                        &build_metadata::current_build_metadata(&build_args.folder, version),
+                    );
                     std::process::exit(0)
                 }
             };
         }
         cli::Command::Watch(watch_args) => {
             let _lock = get_lock(&watch_args.folder);
 
-            watcher::start(
+            if is_clean_build_needed(&watch_args.folder, version) {
+                match build::clean::clean(
+                    &watch_args.folder,
+                    show_progress,
+                    *watch_args.snapshot_output,
+                    *watch_args.dev,
+                ) {
+                    Ok(_) => {}
+                    Err(e) => {
+                        println!("{e}");
+                        std::process::exit(1);
+                    }
+                }
+            }
+
+            match watcher::start(
                 &watch_args.filter,
                 show_progress,
                 &watch_args.folder,
                 (*watch_args.after_build).clone(),
                 *watch_args.create_sourcedirs,
                 *watch_args.dev,
                 *watch_args.snapshot_output,
-            );
-
-            Ok(())
+            ) {
+                Ok(_) => {
+                    build_metadata::write_build_metadata(
+                        &watch_args.folder.join("lib"),
+                        &build_metadata::current_build_metadata(&watch_args.folder, version),
+                    );
+                    std::process::exit(0)
+                }
+                Err(e) => {
+                    println!("{e:?}");
+                    std::process::exit(1)
+                }
+            }
         }
         cli::Command::Clean {
             folder,
@@ -95,6 +141,12 @@ fn main() -> Result<()> {
     }
 }
 
+fn is_clean_build_needed(path: &Path, version: &str) -> bool {
+    let last_build_metadata = build_metadata::read_build_metadata(path);
+    let current_build_metadata = build_metadata::current_build_metadata(path, version);
+    build_metadata::is_build_metadata_different(last_build_metadata.as_ref(), &current_build_metadata)
+}
+
 fn get_lock(folder: &Path) -> lock::Lock {
     match lock::get(folder) {
         lock::Lock::Error(error) => {

rewatch/src/watcher.rs

@@ -316,7 +316,7 @@ pub fn start(
     create_sourcedirs: bool,
     build_dev_deps: bool,
     snapshot_output: bool,
-) {
+) -> Result<(), Error> {
     futures::executor::block_on(async {
         let queue = Arc::new(FifoQueue::<Result<Event, Error>>::new());
         let producer = queue.clone();
@@ -331,7 +331,7 @@ pub fn start(
             .watch(folder.as_ref(), RecursiveMode::Recursive)
             .expect("Could not start watcher");
 
-        if let Err(e) = async_watch(AsyncWatchArgs {
+        async_watch(AsyncWatchArgs {
             q: consumer,
             path: folder,
             show_progress,
@@ -342,8 +342,5 @@ pub fn start(
             snapshot_output,
         })
         .await
-        {
-            println!("{e:?}")
-        }
     })
 }