made Data into an Arc<InnerData>

Author: NULLx76

src/data.rs

@@ -2,7 +2,7 @@ use enum_map::{Enum, EnumMap};
 use serde_derive::{Deserialize, Serialize};
 use tokio::sync::Mutex;
 use tokio::task::{spawn_blocking, JoinSet};
-use tracing::{debug, info, trace};
+use tracing::debug;
 
 use crate::config::Config;
 use std::collections::BTreeMap;
@@ -31,64 +31,66 @@ pub struct Repo {
     pub has_cargo_lock: bool,
 }
 
-#[derive(Debug, Clone)]
-pub struct Data {
+#[derive(Debug)]
+pub struct InnerData {
     data_dir: PathBuf,
 
-    state_lock: Arc<Mutex<()>>,
+    state_lock: Mutex<()>,
 
-    state_cache: Arc<State>,
+    state_cache: State,
 
-    repos_state: Arc<Mutex<EnumMap<Forge, BTreeMap<String, Repo>>>>,
+    repos_state: Mutex<EnumMap<Forge, BTreeMap<String, Repo>>>,
 }
 
+#[derive(Debug, Clone)]
+pub struct Data(Arc<InnerData>);
+
 impl Data {
     pub fn new(config: &Config) -> color_eyre::Result<Self> {
         fs::create_dir_all(&config.data_dir)?;
 
-        let mut data = Data {
-            data_dir: config.data_dir.clone(),
-
-            state_lock: Arc::new(Mutex::new(())),
-            state_cache: Arc::new(State::default()),
-            repos_state: Arc::new(Mutex::new(EnumMap::default())),
+        let state_path = config.data_dir.join("state.json");
+        let state_cache = if state_path.exists() {
+            serde_json::from_slice(&fs::read(&state_path)?)?
+        } else {
+            State::default()
         };
 
-        let state_path = data.state_path();
-        if state_path.exists() {
-            let state_cache: State = serde_json::from_slice(&fs::read(&state_path)?)?;
+        let data = Self(Arc::new(InnerData {
+            data_dir: config.data_dir.clone(),
 
-            data.state_cache = Arc::new(state_cache)
-        }
+            state_lock: Mutex::new(()),
+            state_cache,
+            repos_state: Mutex::new(EnumMap::default()),
+        }));
 
         Ok(data)
     }
 
     pub fn state_path(&self) -> PathBuf {
-        self.data_dir.join("state.json")
+        self.0.data_dir.join("state.json")
     }
 
     pub fn csv_path(&self, forge: Forge) -> PathBuf {
         match forge {
-            Forge::Github => self.data_dir.join("github.csv"),
+            Forge::Github => self.0.data_dir.join("github.csv"),
         }
     }
 
     pub fn get_last_id(&self, forge: Forge) -> usize {
-        self.state_cache.0[forge].load(std::sync::atomic::Ordering::SeqCst)
+        self.0.state_cache.0[forge].load(std::sync::atomic::Ordering::SeqCst)
     }
 
     /// Store the state cache to disk, i.e. last fetched ids
     async fn store_state_cache(&self) -> color_eyre::Result<()> {
-        let state = self.state_cache.clone();
-        let lock = self.state_lock.clone();
+        let this = self.clone();
         let state_path = self.state_path();
         spawn_blocking(move || -> color_eyre::Result<()> {
-            let guard = lock.blocking_lock();
+            let guard = this.0.state_lock.blocking_lock();
 
             let file = File::create(state_path)?;
             let mut file = BufWriter::new(file);
-            serde_json::to_writer_pretty(&mut file, state.as_ref())?;
+            serde_json::to_writer_pretty(&mut file, &this.0.state_cache)?;
             file.write_all(b"\n")?;
 
             drop(guard);
@@ -102,7 +104,7 @@ impl Data {
     /// Stores the repos found to disk in a CSV
     async fn store_csv(&self) -> color_eyre::Result<()> {
         debug!("storing csv file");
-        let mut repos = self.repos_state.lock().await;
+        let mut repos = self.0.repos_state.lock().await;
 
         let mut js = JoinSet::new();
 
@@ -139,7 +141,7 @@ impl Data {
     }
 
     pub async fn set_last_id(&self, forge: Forge, n: usize) -> color_eyre::Result<()> {
-        self.state_cache.0[forge].store(n, std::sync::atomic::Ordering::SeqCst);
+        self.0.state_cache.0[forge].store(n, std::sync::atomic::Ordering::SeqCst);
 
         self.store_csv().await?;
         self.store_state_cache().await?;
@@ -148,7 +150,7 @@ impl Data {
     }
 
     pub async fn store_repo(&self, forge: Forge, repo: Repo) {
-        let mut repos_state = self.repos_state.lock().await;
+        let mut repos_state = self.0.repos_state.lock().await;
         repos_state[forge].insert(repo.name.clone(), repo);
     }
 }

src/github/api.rs

@@ -78,7 +78,7 @@ pub struct GraphRepository {
 }
 
 impl GraphRepository {
-    pub fn to_repo(self, has_cargo_toml: bool, has_cargo_lock: bool) -> Repo {
+    pub fn into_repo(self, has_cargo_toml: bool, has_cargo_lock: bool) -> Repo {
         Repo {
             id: self.id,
             name: self.name_with_owner,

src/github/mod.rs

@@ -60,7 +60,7 @@ impl Scraper {
                 .filter_map(Option::as_ref)
                 .any(|el| el.name == "Rust")
             {
-                let mut repo = repo.to_repo(false, false);
+                let mut repo = repo.into_repo(false, false);
                 let files = self.gh.tree(&repo, false).await;
                 match files {
                     Ok(tree) => {