Extract modules `crate::command::dependencies::{graph,builder,walker}…

…` to `crate::graph`

src/command/dependencies.rs

@@ -4,11 +4,8 @@
 
 pub mod options;
 
-pub(crate) mod builder;
 pub(crate) mod command;
 pub(super) mod cycles;
 pub(super) mod filter;
-pub(crate) mod graph;
 pub(super) mod printer;
 pub(super) mod theme;
-pub(super) mod walker;

src/command/dependencies/command.rs

@@ -8,13 +8,14 @@ use petgraph::graph::NodeIndex;
 use ra_ap_hir as hir;
 use ra_ap_ide::RootDatabase;
 
-use crate::analyzer::LoadOptions;
+use crate::{
+    analyzer::LoadOptions,
+    graph::{Graph, GraphBuilder},
+};
 
 use super::{
-    builder::Builder,
     cycles::tri_color::{CycleDetector, TriColorDepthFirstSearch},
     filter::Filter,
-    graph::Graph,
     options::{LayoutAlgorithm, Options},
     printer::Printer,
 };
@@ -36,7 +37,7 @@ impl Command {
     pub fn run(self, krate: hir::Crate, db: &RootDatabase) -> anyhow::Result<()> {
         trace!("Building graph ...");
 
-        let builder = Builder::new(self.options.clone(), db, krate);
+        let builder = GraphBuilder::new(db, krate);
         let (graph, crate_node_idx) = builder.build()?;
 
         if self.options.acyclic {

src/command/dependencies/cycles/tri_color.rs

@@ -20,7 +20,7 @@ use std::{marker::PhantomData, ops::ControlFlow};
 use bitvec::vec::BitVec;
 use petgraph::graph::{IndexType, NodeIndex};
 
-use super::super::graph::Graph as G;
+use crate::graph::Graph as G;
 
 struct BitSet<T> {
     vec: BitVec,

src/command/dependencies/filter.rs

@@ -15,14 +15,13 @@ use ra_ap_hir::{self as hir};
 use ra_ap_ide_db::RootDatabase;
 use ra_ap_syntax::ast;
 
-use crate::analyzer;
-
-use super::{
-    graph::{Edge, EdgeKind, Graph},
-    options::Options,
-    walker::GraphWalker,
+use crate::{
+    analyzer,
+    graph::{Edge, EdgeKind, Graph, GraphWalker},
 };
 
+use super::options::Options;
+
 #[derive(Debug)]
 pub struct Filter<'a> {
     options: &'a Options,

src/command/dependencies/printer.rs

@@ -13,10 +13,13 @@ use petgraph::{
 use ra_ap_hir as hir;
 use ra_ap_ide::RootDatabase;
 
-use crate::{analyzer, item::visibility::ItemVisibility};
+use crate::{
+    analyzer,
+    graph::{Edge, EdgeKind, Graph, Node},
+    item::visibility::ItemVisibility,
+};
 
 use super::{
-    graph::{Edge, EdgeKind, Graph, Node},
     options::Options,
     theme::{edge_styles, node_styles},
 };

src/command/dependencies/graph.rs → src/graph.rs

@@ -8,6 +8,11 @@ use petgraph::stable_graph::StableGraph;
 
 use crate::item::Item;
 
+mod builder;
+mod walker;
+
+pub(crate) use self::{builder::GraphBuilder, walker::GraphWalker};
+
 pub type Graph = StableGraph<Node, Edge>;
 
 #[derive(Clone, PartialEq, Debug)]

src/command/dependencies/builder.rs → src/graph/builder.rs

@@ -13,11 +13,9 @@ use ra_ap_hir_ty::{self as hir_ty, db::HirDatabase as _, TyExt as _};
 use ra_ap_ide_db::{self as ide_db};
 use scopeguard::defer;
 
-use crate::item::Item;
-
-use super::{
+use crate::{
     graph::{Edge, EdgeKind, Graph, Node},
-    options::Options,
+    item::Item,
 };
 
 #[derive(Debug, Hash, Eq, PartialEq)]
@@ -27,24 +25,21 @@ struct Dependency {
 }
 
 #[derive(Debug)]
-pub struct Builder<'a> {
-    #[allow(dead_code)]
-    options: Options,
+pub struct GraphBuilder<'a> {
     db: &'a ide_db::RootDatabase,
     krate: hir::Crate,
     graph: Graph,
     nodes: HashMap<hir::ModuleDef, NodeIndex>,
     edges: HashMap<(NodeIndex, EdgeKind, NodeIndex), EdgeIndex>,
 }
 
-impl<'a> Builder<'a> {
-    pub fn new(options: Options, db: &'a ide_db::RootDatabase, krate: hir::Crate) -> Self {
+impl<'a> GraphBuilder<'a> {
+    pub fn new(db: &'a ide_db::RootDatabase, krate: hir::Crate) -> Self {
         let graph = Graph::default();
         let nodes = HashMap::default();
         let edges = HashMap::default();
 
         Self {
-            options,
             db,
             krate,
             graph,

src/command/dependencies/walker.rs → src/graph/walker.rs

@@ -6,7 +6,7 @@ use std::collections::HashSet;
 
 use petgraph::{graph::NodeIndex, visit::EdgeRef, Direction};
 
-use super::graph::{Edge, Graph, Node};
+use crate::graph::{Edge, Graph, Node};
 
 pub(crate) struct GraphWalker {
     direction: Direction,

src/lib.rs

@@ -7,5 +7,6 @@ pub mod options;
 
 pub(crate) mod analyzer;
 pub(crate) mod colors;
+pub(crate) mod graph;
 pub(crate) mod item;
 pub(crate) mod tree;