Define read_cache_data_map_file in Rust

This is not much more performant in itself, but we might as well move
this down before trying to optimize.

Author: seddonym

rust/src/caching.rs

@@ -0,0 +1,55 @@
+use crate::errors::{GrimpError, GrimpResult};
+use crate::filesystem::get_file_system_boxed;
+use crate::import_scanning::{DirectImport, imports_by_module_to_py};
+use crate::module_finding::Module;
+use pyo3::types::PyDict;
+use pyo3::{Bound, PyAny, PyResult, Python, pyfunction};
+use std::collections::{HashMap, HashSet};
+
+/// Reads the cache file containing all the imports for a given package.
+/// Args:
+/// - filename: str
+/// - file_system: The file system interface to use. (A BasicFileSystem.)
+/// Returns Dict[Module, Set[DirectImport]]
+#[pyfunction]
+pub fn read_cache_data_map_file<'py>(
+    py: Python<'py>,
+    filename: &str,
+    file_system: Bound<'py, PyAny>,
+) -> PyResult<Bound<'py, PyDict>> {
+    let file_system_boxed = get_file_system_boxed(&file_system)?;
+
+    let file_contents = file_system_boxed.read(filename)?;
+
+    let imports_by_module = parse_json_to_map(&file_contents, filename)?;
+
+    Ok(imports_by_module_to_py(py, imports_by_module))
+}
+
+pub fn parse_json_to_map(
+    json_str: &str,
+    filename: &str,
+) -> GrimpResult<HashMap<Module, HashSet<DirectImport>>> {
+    let raw_map: HashMap<String, Vec<(String, usize, String)>> = serde_json::from_str(json_str)
+        .map_err(|_| GrimpError::CorruptCache(filename.to_string()))?;
+
+    let mut parsed_map: HashMap<Module, HashSet<DirectImport>> = HashMap::new();
+
+    for (module_name, imports) in raw_map {
+        let module = Module {
+            name: module_name.clone(),
+        };
+        let import_set: HashSet<DirectImport> = imports
+            .into_iter()
+            .map(|(imported, line_number, line_contents)| DirectImport {
+                importer: module_name.clone(),
+                imported,
+                line_number,
+                line_contents,
+            })
+            .collect();
+        parsed_map.insert(module, import_set);
+    }
+
+    Ok(parsed_map)
+}

rust/src/import_scanning.rs

@@ -1,3 +1,4 @@
+use serde::Deserialize;
 use crate::errors::GrimpResult;
 use crate::filesystem::FileSystem;
 use crate::{import_parsing, module_finding};
@@ -10,7 +11,7 @@ use rayon::prelude::*;
 use std::collections::{HashMap, HashSet};
 use std::io::{self, ErrorKind};
 
-#[derive(Debug, Hash, Eq, PartialEq)]
+#[derive(Debug, Hash, Eq, PartialEq, Deserialize)]
 pub struct DirectImport {
     pub importer: String,
     pub imported: String,

rust/src/lib.rs

@@ -1,3 +1,4 @@
+mod caching;
 pub mod errors;
 pub mod exceptions;
 mod filesystem;
@@ -7,13 +8,14 @@ mod import_scanning;
 pub mod module_expressions;
 mod module_finding;
 
+use crate::caching::read_cache_data_map_file;
 use crate::errors::{GrimpError, GrimpResult};
 use crate::exceptions::{CorruptCache, InvalidModuleExpression, ModuleNotPresent, NoSuchContainer, ParseError};
 use crate::filesystem::{PyFakeBasicFileSystem, PyRealBasicFileSystem};
 use crate::graph::higher_order_queries::Level;
 use crate::graph::{Graph, Module, ModuleIterator, ModuleTokenIterator};
 use crate::import_scanning::{
-    py_found_packages_to_rust, scan_for_imports_no_py, to_py_direct_imports,
+    py_found_packages_to_rust, scan_for_imports_no_py,
 };
 use crate::module_expressions::ModuleExpression;
 use derive_new::new;
@@ -30,6 +32,7 @@ use std::collections::HashSet;
 #[pymodule]
 fn _rustgrimp(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(scan_for_imports))?;
+    m.add_wrapped(wrap_pyfunction!(read_cache_data_map_file))?;
     m.add_class::<GraphWrapper>()?;
     m.add_class::<PyRealBasicFileSystem>()?;
     m.add_class::<PyFakeBasicFileSystem>()?;