finchie/depwiz - Change UXJFRBBL7IZ2PR7ZYNFGOJ6A7EH5ZVLYVFLA3HNFCNRVL6KWJUDAC

Move graph functionality into `graph` module

Makes main.rs much less cluttered, but does not move the rendering code itself, as the goal is for that to get split into a separate module, e.g. render.rs.

Created by finchie on April 22, 2024

UXJFRBBL7IZ2PR7ZYNFGOJ6A7EH5ZVLYVFLA3HNFCNRVL6KWJUDAC

Dependencies

In channels

main

Change contents

Deletion in src/main.rs at line 1 [3.49]
B:BD[3.49] → [2.0:32]
```
use std::collections::HashMap;
```
Replacement in src/main.rs at line 2 [3.49]
B:BD[4.85] → [2.33:58]
∅:D[2.58] → [5.0:13]
B:BD[4.85] → [5.0:13]
B:BD[5.13] → [2.59:119]
B:BD[2.119] → [2.119:151]
∅:D[5.82] → [6.123:126]
∅:D[4.147] → [6.123:126]
∅:D[2.151] → [6.123:126]
B:BD[6.123] → [6.123:126]
```
use forceatlas2::Layout;
use guppy::{
    graph::{DependencyDirection, PackageGraph, PackageSet},
    MetadataCommand, PackageId,
};
```
[4.85]
[7.2711]
```
use guppy::{graph::PackageGraph, MetadataCommand};
```
Insertion in src/main.rs at line 4 [3.49]
[7.2712]
[7.2712]
```
mod graph;
```

Deletion in src/main.rs at line 6 [3.49]

B:BD[7.2725] → [2.152:484]

∅:D[2.484] → [3.265:266]

∅:D[7.2725] → [3.265:266]

B:BD[3.265] → [3.265:266]

B:BD[3.266] → [2.485:1077]


fn graph_layout<'graph>(
    package_set: &'graph PackageSet,
) -> impl Iterator<Item = (&'graph PackageId, forceatlas2::Node<f64, 2>)> {
    let link_index: HashMap<&PackageId, usize> = package_set
        .package_ids(DependencyDirection::Forward)
        .enumerate()
        .map(|(index, id)| (id, index))
        .collect();
    let edges = package_set
        .links(DependencyDirection::Forward)
        .map(|link| (link.from(), link.to()))
        .map(|(from, to)| (link_index.get(from.id()), link_index.get(to.id())))
        .map(|(from, to)| (*from.unwrap(), *to.unwrap()))
        .map(|edge| (edge, 1.0))
        .collect();
    let sizes = package_set
        .package_ids(DependencyDirection::Forward)
        .map(|_id| 1.0);
    let mut layout =
        Layout::from_graph_with_degree_mass(edges, sizes, forceatlas2::Settings::default());
    for _step in 0..1_000 {
        layout.iteration();
    }

Deletion in src/main.rs at line 7 [3.49]

B:BD[2.1078] → [2.1078:1414]

∅:D[2.1414] → [5.83:259]

B:BD[3.266] → [5.83:259]

B:BD[5.259] → [2.1415:1503]

∅:D[5.259] → [4.429:430]

∅:D[2.1503] → [4.429:430]

B:BD[4.429] → [4.429:430]

B:BD[4.430] → [2.1504:1746]

∅:D[2.1746] → [5.541:680]

B:BD[5.541] → [5.541:680]

∅:D[5.680] → [6.761:762]

B:BD[6.761] → [6.761:762]

B:BD[6.762] → [5.681:1089]

∅:D[5.1089] → [6.1215:1216]

B:BD[6.1215] → [6.1215:1216]

B:BD[6.1216] → [5.1090:1174]

∅:D[5.1174] → [3.697:706]

B:BD[3.697] → [3.697:706]

    // TODO: validate that PackageSet::package_ids() is stable; it is used twice (link_index, here)
    // so need to validate ordering is consistent (or, find a cleaner solution)
    layout
        .nodes
        .into_iter()
        .zip(package_set.package_ids(DependencyDirection::Forward))
        .map(|(node, id)| (id, node))
}
fn graph_data(graph: &PackageGraph) -> charming::series::GraphData {
    let categories = vec![charming::series::GraphCategory {
        name: String::from("default"),
    }];
    let package_set = graph.resolve_all();
    let layout = graph_layout(&package_set);
    let nodes = layout
        .map(|(id, node)| charming::series::GraphNode {
            id: id.repr().to_string(),
            name: graph.metadata(id).unwrap().name().to_string(),
            x: node.pos.x(),
            y: node.pos.y(),
            value: 1_f64,
            category: 0,
            symbol_size: 1_f64,
            label: None,
        })
        .collect();
    let links = graph
        .query_forward(graph.package_ids())
        .unwrap()
        .resolve()
        .links(DependencyDirection::Forward)
        .map(|link| link.endpoints())
        .map(|(source, target)| charming::series::GraphLink {
            source: source.id().repr().to_string(),
            target: target.id().repr().to_string(),
            value: None,
        })
        .collect();
    charming::series::GraphData {
        nodes,
        links,
        categories,
    }
}

Replacement in src/main.rs at line 18 [3.49]

B:BD[6.1460] → [5.1289:1336]

            .data(graph_data(&package_graph)),

[6.1460]

[6.1499]

            .data(graph::data(&package_graph)),

File addition: graph.rs (----------)

[3.15]

use std::collections::HashMap;
use forceatlas2::Layout;
use guppy::{
    graph::{DependencyDirection, PackageGraph, PackageSet},
    PackageId,
};
fn layout<'graph>(
    package_set: &'graph PackageSet,
) -> impl Iterator<Item = (&'graph PackageId, forceatlas2::Node<f64, 2>)> {
    let link_index: HashMap<&PackageId, usize> = package_set
        .package_ids(DependencyDirection::Forward)
        .enumerate()
        .map(|(index, id)| (id, index))
        .collect();
    let edges = package_set
        .links(DependencyDirection::Forward)
        .map(|link| (link.from(), link.to()))
        .map(|(from, to)| (link_index.get(from.id()), link_index.get(to.id())))
        .map(|(from, to)| (*from.unwrap(), *to.unwrap()))
        .map(|edge| (edge, 1.0))
        .collect();
    let sizes = package_set
        .package_ids(DependencyDirection::Forward)
        .map(|_id| 1.0);
    let mut layout =
        Layout::from_graph_with_degree_mass(edges, sizes, forceatlas2::Settings::default());
    for _step in 0..1_000 {
        layout.iteration();
    }
    // TODO: validate that PackageSet::package_ids() is stable; it is used twice (link_index, here)
    // so need to validate ordering is consistent (or, find a cleaner solution)
    layout
        .nodes
        .into_iter()
        .zip(package_set.package_ids(DependencyDirection::Forward))
        .map(|(node, id)| (id, node))
}
pub fn data(graph: &PackageGraph) -> charming::series::GraphData {
    let categories = vec![charming::series::GraphCategory {
        name: String::from("default"),
    }];
    let package_set = graph.resolve_all();
    let layout = layout(&package_set);
    let nodes = layout
        .map(|(id, node)| charming::series::GraphNode {
            id: id.repr().to_string(),
            name: graph.metadata(id).unwrap().name().to_string(),
            x: node.pos.x(),
            y: node.pos.y(),
            value: 1_f64,
            category: 0,
            symbol_size: 1_f64,
            label: None,
        })
        .collect();
    let links = graph
        .query_forward(graph.package_ids())
        .unwrap()
        .resolve()
        .links(DependencyDirection::Forward)
        .map(|link| link.endpoints())
        .map(|(source, target)| charming::series::GraphLink {
            source: source.id().repr().to_string(),
            target: target.id().repr().to_string(),
            value: None,
        })
        .collect();
    charming::series::GraphData {
        nodes,
        links,
        categories,
    }
}