editoast: expand naming of variables

editoast/src/views/v2/path/pathfinding.rs

@@ -118,33 +118,45 @@ async fn pathfinding_blocks_batch(
     redis_conn: &mut RedisConnection,
     core: Arc<CoreClient>,
     infra: &Infra,
-    path_inputs: &[PathfindingInput],
+    pathfinding_inputs: &[PathfindingInput],
 ) -> Result<Vec<PathfindingResult>> {
     // Compute hashes of all path_inputs
-    let hashes: Vec<_> = path_inputs
+    let hashes: Vec<_> = pathfinding_inputs
         .iter()
         .map(|input| path_input_hash(infra.id, &infra.version, input))
         .collect();
 
     // Try to retrieve the result from Redis
-    let mut results: Vec<Option<PathfindingResult>> = redis_conn.json_get_bulk(&hashes).await?;
+    let mut pathfinding_results: Vec<Option<PathfindingResult>> =
+        redis_conn.json_get_bulk(&hashes).await?;
 
     // Report number of hit cache
-    let nb_hit = results.iter().filter(|res| res.is_some()).count();
-    info!(nb_hit, nb_miss = path_inputs.len() - nb_hit, "Hit cache");
+    let nb_hit = pathfinding_results
+        .iter()
+        .filter(|pathfinding_result| pathfinding_result.is_some())
+        .count();
+    info!(
+        nb_hit,
+        nb_miss = pathfinding_inputs.len() - nb_hit,
+        "Hit cache"
+    );
 
     // Handle miss cache:
     // 1) extract locations from path items
     let mut to_cache = vec![];
     let mut pathfinding_requests = vec![];
     let mut pathfinding_requests_index = vec![];
-    for (index, (result, path_input)) in results.iter_mut().zip(path_inputs).enumerate() {
-        if result.is_some() {
+    for (index, (pathfinding_result, pathfinding_input)) in pathfinding_results
+        .iter_mut()
+        .zip(pathfinding_inputs)
+        .enumerate()
+    {
+        if pathfinding_result.is_some() {
             continue;
         }
-        let path_items = path_input.clone().path_items;
+        let path_items = pathfinding_input.clone().path_items;
         if path_items.len() <= 1 {
-            *result = Some(PathfindingResult::NotEnoughPathItems);
+            *pathfinding_result = Some(PathfindingResult::NotEnoughPathItems);
             to_cache.push((&hashes[index], PathfindingResult::NotEnoughPathItems));
             continue;
         }
@@ -153,18 +165,18 @@ async fn pathfinding_blocks_batch(
             Ok(track_offsets) => track_offsets,
             Err(e) => {
                 let err: PathfindingResult = e.into();
-                *result = Some(err.clone());
+                *pathfinding_result = Some(err.clone());
                 to_cache.push((&hashes[index], err));
                 continue;
             }
         };
 
         // Check if tracks exist
-        if let Err(pathfinding_result) =
+        if let Err(pathfinding) =
             check_tracks_from_path_items(conn, infra.id, &track_offsets).await?
         {
-            *result = Some(pathfinding_result.clone());
-            to_cache.push((&hashes[index], pathfinding_result));
+            *pathfinding_result = Some(pathfinding.clone());
+            to_cache.push((&hashes[index], pathfinding));
             continue;
         }
 
@@ -173,12 +185,12 @@ async fn pathfinding_blocks_batch(
             infra: infra.id,
             expected_version: infra.version.clone(),
             path_items: track_offsets,
-            rolling_stock_loading_gauge: path_input.rolling_stock_loading_gauge,
-            rolling_stock_is_thermal: path_input.rolling_stock_is_thermal,
-            rolling_stock_supported_electrifications: path_input
+            rolling_stock_loading_gauge: pathfinding_input.rolling_stock_loading_gauge,
+            rolling_stock_is_thermal: pathfinding_input.rolling_stock_is_thermal,
+            rolling_stock_supported_electrifications: pathfinding_input
                 .rolling_stock_supported_electrifications
                 .clone(),
-            rolling_stock_supported_signaling_systems: path_input
+            rolling_stock_supported_signaling_systems: pathfinding_input
                 .rolling_stock_supported_signaling_systems
                 .clone(),
         };
@@ -199,13 +211,13 @@ async fn pathfinding_blocks_batch(
     for (index, computed_path) in computed_paths.into_iter().enumerate() {
         let path_index = pathfinding_requests_index[index];
         to_cache.push((&hashes[path_index], computed_path.clone()));
-        results[path_index] = Some(computed_path);
+        pathfinding_results[path_index] = Some(computed_path);
     }
 
     // 3) Put in cache
     redis_conn.json_set_bulk(&to_cache).await?;
 
-    Ok(results.into_iter().flatten().collect())
+    Ok(pathfinding_results.into_iter().flatten().collect())
 }
 
 /// Compute a path given a train schedule and an infrastructure.