formatting and adding a buncha log points

Author: Strum355

server/src/commands.rs

@@ -1,34 +1,37 @@
-use std::{collections::HashMap, path::{Path, PathBuf}};
-use std::rc::Rc;
 use std::cell::RefCell;
 use std::fs::OpenOptions;
 use std::io::prelude::*;
+use std::rc::Rc;
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
 
+use petgraph::dot::Config;
 use serde_json::Value;
 
 use petgraph::{dot, graph::NodeIndex};
 
-use anyhow::{Result, format_err};
+use anyhow::{format_err, Result};
+use slog_scope::info;
 
 use std::fs;
 
-use crate::{graph::CachedStableGraph, merge_views, url_norm::FromJson};
 use crate::dfs;
+use crate::{graph::CachedStableGraph, merge_views, url_norm::FromJson};
 
 pub struct CustomCommandProvider {
-    commands: HashMap<String, Box<dyn Invokeable>>
+    commands: HashMap<String, Box<dyn Invokeable>>,
 }
 
 impl CustomCommandProvider {
     pub fn new(commands: Vec<(&str, Box<dyn Invokeable>)>) -> CustomCommandProvider {
-       CustomCommandProvider{
-            commands: commands.into_iter().map(|tup| {
-                (tup.0.into(), tup.1)
-            }).collect(),
+        CustomCommandProvider {
+            commands: commands.into_iter().map(|tup| (tup.0.into(), tup.1)).collect(),
         }
     }
 
-    pub fn execute(&self, command: &str, args: Vec<Value>, root_path: &Path) -> Result<Value> {
+    pub fn execute(&self, command: &str, args: &[Value], root_path: &Path) -> Result<Value> {
         if self.commands.contains_key(command) {
             return self.commands.get(command).unwrap().run_command(root_path, args);
         }
@@ -37,43 +40,42 @@ impl CustomCommandProvider {
 }
 
 pub trait Invokeable {
-    fn run_command(&self, root: &Path, arguments: Vec<Value>) -> Result<Value>;
+    fn run_command(&self, root: &Path, arguments: &[Value]) -> Result<Value>;
 }
 
 pub struct GraphDotCommand {
-    pub graph: Rc<RefCell<CachedStableGraph>>
+    pub graph: Rc<RefCell<CachedStableGraph>>,
 }
 
 impl Invokeable for GraphDotCommand {
-    fn run_command(&self, root: &Path, _: Vec<Value>) -> Result<Value> {
+    fn run_command(&self, root: &Path, _: &[Value]) -> Result<Value> {
         let filepath = root.join("graph.dot");
-        eprintln!("generating dot file at {:?}", filepath);
-        let mut file = OpenOptions::new()
-            .truncate(true)
-            .write(true)
-            .create(true)
-            .open(filepath)
-            .unwrap();
+
+        info!("generating dot file"; "path" => filepath.as_os_str().to_str());
+
+        let mut file = OpenOptions::new().truncate(true).write(true).create(true).open(filepath).unwrap();
 
         let mut write_data_closure = || -> Result<(), std::io::Error> {
             let graph = self.graph.as_ref();
 
             file.seek(std::io::SeekFrom::Start(0))?;
-            file.write_all(dot::Dot::new(&graph.borrow().graph).to_string().as_bytes())?;
+            file.write_all("digraph {\n\tgraph [splines=ortho]\n\tnode [shape=box]\n".as_bytes())?;
+            file.write_all(dot::Dot::with_config(&graph.borrow().graph, &[Config::GraphContentOnly]).to_string().as_bytes())?;
+            file.write_all("\n}".as_bytes())?;
             file.flush()?;
             file.seek(std::io::SeekFrom::Start(0))?;
             Ok(())
         };
 
         match write_data_closure() {
-            Err(err) => Err(format_err!("Error generating graphviz data: {}", err)),
-            _ => Ok(Value::Null)
+            Err(err) => Err(format_err!("error generating graphviz data: {}", err)),
+            _ => Ok(Value::Null),
         }
     }
 }
 
 pub struct VirtualMergedDocument {
-    pub graph: Rc<RefCell<CachedStableGraph>>
+    pub graph: Rc<RefCell<CachedStableGraph>>,
 }
 
 impl VirtualMergedDocument {
@@ -111,7 +113,7 @@ impl VirtualMergedDocument {
 
             let source = match fs::read_to_string(&path) {
                 Ok(s) => s,
-                Err(e) => return Err(format_err!("error reading {:?}: {}", path, e))
+                Err(e) => return Err(format_err!("error reading {:?}: {}", path, e)),
             };
             let source = source.replace("\r\n", "\n");
             sources.insert(path.clone(), source);
@@ -122,7 +124,7 @@ impl VirtualMergedDocument {
 }
 
 impl Invokeable for VirtualMergedDocument {
-    fn run_command(&self, root: &Path, arguments: Vec<Value>) -> Result<Value> {
+    fn run_command(&self, root: &Path, arguments: &[Value]) -> Result<Value> {
         let path = PathBuf::from_json(arguments.get(0).unwrap())?;
 
         let file_ancestors = match self.get_file_toplevel_ancestors(&path) {
@@ -132,15 +134,15 @@ impl Invokeable for VirtualMergedDocument {
             },
             Err(e) => return Err(e),
         };
-        
-        //eprintln!("ancestors for {}:\n\t{:?}", path, file_ancestors.iter().map(|e| self.graph.borrow().graph.node_weight(*e).unwrap().clone()).collect::<Vec<String>>());
+
+        //info!("ancestors for {}:\n\t{:?}", path, file_ancestors.iter().map(|e| self.graph.borrow().graph.node_weight(*e).unwrap().clone()).collect::<Vec<String>>());
 
         // the set of all filepath->content. TODO: change to Url?
         let mut all_sources: HashMap<PathBuf, String> = HashMap::new();
 
         // if we are a top-level file (this has to be one of the set defined by Optifine, right?)
         if file_ancestors.is_empty() {
-            // gather the list of all descendants 
+            // gather the list of all descendants
             let root = self.graph.borrow_mut().find_node(&path).unwrap();
             let tree = match self.get_dfs_for_node(root) {
                 Ok(tree) => tree,
@@ -149,14 +151,17 @@ impl Invokeable for VirtualMergedDocument {
 
             let sources = match self.load_sources(&tree) {
                 Ok(s) => s,
-                Err(e) => return Err(e)
+                Err(e) => return Err(e),
             };
             all_sources.extend(sources);
 
             let graph = self.graph.borrow();
             let view = merge_views::generate_merge_list(&tree, &all_sources, &graph);
             return Ok(serde_json::value::Value::String(view));
         }
-        return Err(format_err!("{:?} is not a top-level file aka has ancestors", path.strip_prefix(root).unwrap()))
+        return Err(format_err!(
+            "{:?} is not a top-level file aka has ancestors",
+            path.strip_prefix(root).unwrap()
+        ));
     }
-}
+}

server/src/dfs.rs

@@ -10,19 +10,19 @@ struct VisitCount {
     children: usize,
 }
 
-/// Performs a depth-first search with duplicates 
+/// Performs a depth-first search with duplicates
 pub struct Dfs<'a> {
     stack: Vec<NodeIndex>,
     graph: &'a CachedStableGraph,
-    cycle: Vec<VisitCount>
+    cycle: Vec<VisitCount>,
 }
 
-impl <'a> Dfs<'a> {
+impl<'a> Dfs<'a> {
     pub fn new(graph: &'a CachedStableGraph, start: NodeIndex) -> Self {
         Dfs {
             stack: vec![start],
             graph,
-            cycle: Vec::new()
+            cycle: Vec::new(),
         }
     }
 
@@ -42,49 +42,44 @@ impl <'a> Dfs<'a> {
             for child in children {
                 if prev.node == *child {
                     let cycle_nodes: Vec<NodeIndex> = self.cycle.iter().map(|n| n.node).collect();
-                    return Err(
-                        error::CycleError::new(&cycle_nodes, *child, self.graph)
-                    );
+                    return Err(error::CycleError::new(&cycle_nodes, *child, self.graph));
                 }
             }
         }
         Ok(())
-    }   
+    }
 }
 
-impl <'a> Iterator for Dfs<'a> {
+impl<'a> Iterator for Dfs<'a> {
     type Item = Result<(NodeIndex, Option<NodeIndex>), error::CycleError>;
 
     fn next(&mut self) -> Option<Result<(NodeIndex, Option<NodeIndex>), error::CycleError>> {
-        let parent = match self.cycle.last() {
-            Some(p) => Some(p.node),
-            None => None,
-        };
+        let parent = self.cycle.last().map(|p| p.node);
 
         if let Some(node) = self.stack.pop() {
-            self.cycle.push(VisitCount{
+            self.cycle.push(VisitCount {
                 node,
                 children: self.graph.graph.edges(node).count(),
                 touch: 1,
             });
 
             let mut children = self.graph.child_node_indexes(node);
-            
+
             if !children.is_empty() {
                 // sort by line number in parent
                 children.sort_by(|x, y| {
                     let graph = &self.graph.graph;
                     let edge1 = graph.edge_weight(graph.find_edge(node, *x).unwrap()).unwrap();
                     let edge2 = graph.edge_weight(graph.find_edge(node, *y).unwrap()).unwrap();
-    
+
                     edge2.line.cmp(&edge1.line)
                 });
-    
+
                 match self.check_for_cycle(&children) {
                     Ok(_) => {}
                     Err(e) => return Some(Err(e)),
                 };
-    
+
                 for child in children {
                     self.stack.push(child);
                 }
@@ -101,40 +96,44 @@ impl <'a> Iterator for Dfs<'a> {
 pub mod error {
     use petgraph::stable_graph::NodeIndex;
 
-    use std::{fmt::{Debug, Display}, path::PathBuf, error::Error as StdError};
+    use std::{
+        error::Error as StdError,
+        fmt::{Debug, Display},
+        path::PathBuf,
+    };
 
-    use crate::{graph::CachedStableGraph, consts};
+    use crate::{consts, graph::CachedStableGraph};
 
     use rust_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range};
 
     #[derive(Debug)]
     pub struct CycleError(Vec<PathBuf>);
 
     impl StdError for CycleError {}
-    
+
     impl CycleError {
         pub fn new(nodes: &[NodeIndex], current_node: NodeIndex, graph: &CachedStableGraph) -> Self {
             let mut resolved_nodes: Vec<PathBuf> = nodes.iter().map(|i| graph.get_node(*i)).collect();
             resolved_nodes.push(graph.get_node(current_node));
             CycleError(resolved_nodes)
         }
     }
-    
+
     impl Display for CycleError {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             let mut disp = String::new();
             disp.push_str(format!("Include cycle detected:\n{:?} imports ", self.0[0]).as_str());
-            for p in &self.0[1..self.0.len()-1] {
+            for p in &self.0[1..self.0.len() - 1] {
                 disp.push_str(format!("\n{:?}, which imports ", *p).as_str());
             }
-            disp.push_str(format!("\n{:?}", self.0[self.0.len()-1]).as_str());
+            disp.push_str(format!("\n{:?}", self.0[self.0.len() - 1]).as_str());
             f.write_str(disp.as_str())
         }
     }
 
     impl From<CycleError> for Diagnostic {
         fn from(e: CycleError) -> Diagnostic {
-            Diagnostic{
+            Diagnostic {
                 severity: Some(DiagnosticSeverity::Error),
                 range: Range::new(Position::new(0, 0), Position::new(0, 500)),
                 source: Some(consts::SOURCE.into()),
@@ -153,4 +152,4 @@ pub mod error {
             format!("{}", e)
         }
     }
-}
+}

server/src/graph.rs

@@ -1,9 +1,13 @@
-use petgraph::stable_graph::StableDiGraph;
+use petgraph::stable_graph::EdgeIndex;
 use petgraph::stable_graph::NodeIndex;
+use petgraph::stable_graph::StableDiGraph;
 use petgraph::Direction;
-use petgraph::stable_graph::EdgeIndex;
 
-use std::{collections::{HashMap, HashSet}, path::{Path, PathBuf}, str::FromStr};
+use std::{
+    collections::{HashMap, HashSet},
+    path::{Path, PathBuf},
+    str::FromStr,
+};
 
 use super::IncludePosition;
 
@@ -16,14 +20,14 @@ pub struct CachedStableGraph {
     pub graph: StableDiGraph<String, IncludePosition>,
     cache: HashMap<PathBuf, NodeIndex>,
     // Maps a node index to its abstracted string representation.
-    // Mainly used as the graph is based on NodeIndex and 
+    // Mainly used as the graph is based on NodeIndex.
     reverse_index: HashMap<NodeIndex, PathBuf>,
 }
 
 impl CachedStableGraph {
     #[allow(clippy::new_without_default)]
     pub fn new() -> CachedStableGraph {
-        CachedStableGraph{
+        CachedStableGraph {
             graph: StableDiGraph::new(),
             cache: HashMap::new(),
             reverse_index: HashMap::new(),
@@ -91,15 +95,21 @@ impl CachedStableGraph {
 
     #[allow(dead_code)]
     pub fn child_node_names(&self, node: NodeIndex) -> Vec<PathBuf> {
-        self.graph.neighbors(node).map(|n| self.reverse_index.get(&n).unwrap().clone()).collect()
+        self.graph
+            .neighbors(node)
+            .map(|n| self.reverse_index.get(&n).unwrap().clone())
+            .collect()
     }
 
     pub fn child_node_meta(&self, node: NodeIndex) -> Vec<(PathBuf, IncludePosition)> {
-        self.graph.neighbors(node).map(|n| {
-            let edge = self.graph.find_edge(node, n).unwrap();
-            let edge_meta = self.graph.edge_weight(edge).unwrap();
-            return (self.reverse_index.get(&n).unwrap().clone(), edge_meta.clone())
-        }).collect()
+        self.graph
+            .neighbors(node)
+            .map(|n| {
+                let edge = self.graph.find_edge(node, n).unwrap();
+                let edge_meta = self.graph.edge_weight(edge).unwrap();
+                return (self.reverse_index.get(&n).unwrap().clone(), edge_meta.clone());
+            })
+            .collect()
     }
 
     pub fn child_node_indexes(&self, node: NodeIndex) -> Vec<NodeIndex> {
@@ -108,7 +118,10 @@ impl CachedStableGraph {
 
     #[allow(dead_code)]
     pub fn parent_node_names(&self, node: NodeIndex) -> Vec<PathBuf> {
-        self.graph.neighbors_directed(node, Direction::Incoming).map(|n| self.reverse_index.get(&n).unwrap().clone()).collect()
+        self.graph
+            .neighbors_directed(node, Direction::Incoming)
+            .map(|n| self.reverse_index.get(&n).unwrap().clone())
+            .collect()
     }
 
     pub fn parent_node_indexes(&self, node: NodeIndex) -> Vec<NodeIndex> {
@@ -129,7 +142,7 @@ impl CachedStableGraph {
         if node == initial && !visited.is_empty() {
             return vec![];
         }
-        
+
         let parents = self.parent_node_indexes(node);
         let mut collection = Vec::with_capacity(parents.len());
 
@@ -148,4 +161,4 @@ impl CachedStableGraph {
 
         collection
     }
-}
+}