Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
113 changes: 113 additions & 0 deletions document/format/src/layers.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,113 @@
//! Finds the path of every layer in a runtime network, once for each instance of the networks holding it.

use std::collections::HashSet;

use document_graph_storage::NodeMetadataEntry;
use graph_craft::document::{DocumentNodeImplementation, NetworkLocation, NodeId, NodeNetwork};

/// The path of every node its metadata marks as a layer.
pub fn layer_paths(network: &NodeNetwork, node_metadata: &[NodeMetadataEntry]) -> Vec<Vec<NodeId>> {
let layers: HashSet<(NetworkLocation, NodeId)> = node_metadata.iter().filter(|node| node.is_layer).map(|node| (node.network, node.local_id)).collect();

let mut layer_paths = Vec::new();
for_each_network_instance(network, |network_path, nested| {
let Some(location) = network.locate(network_path) else { return };
let nested_layers = nested.nodes.keys().filter(|node_id| layers.contains(&(location, **node_id)));
layer_paths.extend(nested_layers.map(|node_id| [network_path, &[*node_id]].concat()));
});
layer_paths
}

/// Visits every network with its path, once for each instance of it.
/// A definition is not entered again from inside itself.
pub fn for_each_network_instance(network: &NodeNetwork, mut visit: impl FnMut(&[NodeId], &NodeNetwork)) {
let mut stack = vec![(Vec::new(), Vec::new())];
while let Some((network_path, enclosing_definitions)) = stack.pop() {
let Some(nested) = network.nested_network(&network_path) else { continue };
visit(&network_path, nested);

for (node_id, node) in &nested.nodes {
let mut enclosing_definitions = enclosing_definitions.clone();
match node.implementation {
DocumentNodeImplementation::Definition(id) if enclosing_definitions.contains(&id) => continue,
DocumentNodeImplementation::Definition(id) => enclosing_definitions.push(id),
DocumentNodeImplementation::Network(_) => {}
_ => continue,
}
stack.push(([network_path.as_slice(), &[*node_id]].concat(), enclosing_definitions));
}
}
}

#[cfg(test)]
mod tests {
use super::*;
use graph_craft::document::{DocumentNode, NetworkId};

const DEFINITION: NetworkId = NetworkId(9);

fn node_metadata(network: NetworkLocation, local_id: u64, is_layer: bool) -> NodeMetadataEntry {
NodeMetadataEntry {
network,
local_id: NodeId(local_id),
position: None,
is_layer,
display_name: None,
locked: false,
pinned: false,
input_metadata: Vec::new(),
output_names: Vec::new(),
output_descriptions: Vec::new(),
}
}

#[test]
fn a_layer_inside_a_definition_is_found_through_each_instance() {
let instance = DocumentNode {
implementation: DocumentNodeImplementation::Definition(DEFINITION),
..Default::default()
};
let definition = NodeNetwork {
nodes: [3, 4].map(|id| (NodeId(id), DocumentNode::default())).into_iter().collect(),
..Default::default()
};
let network = NodeNetwork {
nodes: [1, 2].map(|id| (NodeId(id), instance.clone())).into_iter().collect(),
definitions: [(DEFINITION, definition)].into_iter().collect(),
..Default::default()
};
let metadata = [(None, 1, true), (None, 2, false), (Some(DEFINITION), 3, true), (Some(DEFINITION), 4, false)];
let metadata: Vec<_> = metadata.into_iter().map(|(location, local_id, is_layer)| node_metadata(location, local_id, is_layer)).collect();

let mut layer_paths = layer_paths(&network, &metadata);
layer_paths.sort();

assert_eq!(layer_paths, vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)], vec![NodeId(2), NodeId(3)]]);
}

#[test]
fn a_definition_holding_itself_is_entered_once() {
let recursive = DocumentNode {
implementation: DocumentNodeImplementation::Definition(DEFINITION),
..Default::default()
};
let network = NodeNetwork {
nodes: [(NodeId(1), recursive.clone())].into_iter().collect(),
definitions: [(
DEFINITION,
NodeNetwork {
nodes: [(NodeId(2), recursive)].into_iter().collect(),
..Default::default()
},
)]
.into_iter()
.collect(),
..Default::default()
};

let mut network_paths = Vec::new();
for_each_network_instance(&network, |network_path, _| network_paths.push(network_path.to_vec()));

assert_eq!(network_paths, vec![vec![], vec![NodeId(1)]]);
}
}
2 changes: 2 additions & 0 deletions document/format/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -29,6 +29,8 @@ pub mod codec;
pub mod error;
pub mod export;
pub mod io;
#[cfg(feature = "conversion")]
pub mod layers;
pub mod layout;
mod load;
pub mod manifest;
Expand Down
12 changes: 7 additions & 5 deletions document/live/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -3,9 +3,9 @@
use document_container::AnyContainer;
use document_container::backends::memory::MemoryBackend;
use document_format::{GddV1, GddV1Layout};
use document_graph_storage::{NodeMetadataEntry, PeerId, UserId};
use document_graph_storage::{PeerId, UserId};
use graph_craft::application_io::resource::ResourceHash;
use graph_craft::document::NodeNetwork;
use graph_craft::document::{NodeId, NodeNetwork};
use peer_transport::{Room, SyncTarget};

pub use document_format::Error as FormatError;
Expand Down Expand Up @@ -97,10 +97,12 @@ impl LiveDocument {
&mut self.gdd
}

/// The document's runtime network, with the metadata of each of its nodes.
pub async fn network_with_metadata(&self) -> Result<(NodeNetwork, Vec<NodeMetadataEntry>), LiveError> {
/// The document's runtime network, with the path of every layer in it.
pub async fn network_with_layers(&self) -> Result<(NodeNetwork, Vec<Vec<NodeId>>), LiveError> {
let declarations = self.gdd.declarations(&self.gdd).await;
Ok(self.gdd.registry().to_runtime_with_metadata(&declarations, self.gdd.blobs())?)
let (network, node_metadata) = self.gdd.registry().to_runtime_with_metadata(&declarations, self.gdd.blobs())?;
let layers = document_format::layers::layer_paths(&network, &node_metadata);
Ok((network, layers))
}

pub fn leave(&mut self) {
Expand Down
119 changes: 115 additions & 4 deletions document/loader/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,8 @@ use document_container::archive::ArchiveFormat;
use document_container::backends::memory::MemoryBackend;
use document_format::{GddV1, GddV1Layout};
use document_graph_storage::{NetworkMetadataEntry, NodeMetadataEntry};
use graph_craft::document::NodeNetwork;
use graph_craft::document::{DocumentNodeImplementation, NodeId, NodeNetwork};
use std::collections::HashMap;
use std::error::Error;
use std::path::Path;

Expand All @@ -17,6 +18,8 @@ use migration_nodes as _;
/// A document's runtime network, with the file it was opened from.
pub struct LoadedDocument {
pub network: NodeNetwork,
/// The path of every layer in `network`, once for each instance of the networks holding it.
pub layers: Vec<Vec<NodeId>>,
pub origin: DocumentOrigin,
}

Expand Down Expand Up @@ -58,24 +61,132 @@ pub async fn open_document(path: &Path) -> Result<LoadedDocument, Box<dyn Error>
let named_gdd = path.extension().is_some_and(|extension| extension.eq_ignore_ascii_case("gdd"));
if !named_gdd && ArchiveFormat::detect(&bytes).is_none() {
let document_string = String::from_utf8(bytes).map_err(|error| format!("Document {} is neither a .gdd archive nor text: {error}", path.display()))?;
let network = legacy_network(&document_string).map_err(|error| format!("Failed to parse legacy document {}: {error}", path.display()))?;
let parse_error = |error| format!("Failed to parse legacy document {}: {error}", path.display());
let document: serde_json::Value = serde_json::from_str(&document_string).map_err(parse_error)?;
let network = legacy_network(&document).map_err(parse_error)?;
let layers = legacy_layer_paths(&network, &document);
return Ok(LoadedDocument {
network,
layers,
origin: DocumentOrigin::Legacy(document_string),
});
}

let gdd = open_gdd(&bytes).await?;
let declarations = gdd.declarations(&gdd).await;
let (network, nodes, networks) = gdd.registry().to_runtime_with_full_metadata(&declarations, gdd.blobs())?;
let layers = document_format::layers::layer_paths(&network, &nodes);
Ok(LoadedDocument {
network,
layers,
origin: DocumentOrigin::Gdd { gdd: Box::new(gdd), nodes, networks },
})
}

fn legacy_network(document_string: &str) -> Result<NodeNetwork, serde_json::Error> {
let document: serde_json::Value = serde_json::from_str(document_string)?;
fn legacy_network(document: &serde_json::Value) -> Result<NodeNetwork, serde_json::Error> {
let network = document["network_interface"]["network"].to_string();
serde_json::from_str(&network)
}

/// The path of every node a legacy document's metadata marks as a layer.
fn legacy_layer_paths(network: &NodeNetwork, document: &serde_json::Value) -> Vec<Vec<NodeId>> {
let mut layer_paths = Vec::new();
document_format::layers::for_each_network_instance(network, |network_path, _| {
let Some(network_metadata) = legacy_network_metadata(network, document, network_path) else {
return;
};
let is_layer = |node_metadata: &serde_json::Value| node_metadata["node_type_metadata"]["Layer"].is_object();
let layers = legacy_node_metadata(network_metadata).into_iter().filter(|(_, node_metadata)| is_layer(node_metadata));
layer_paths.extend(layers.map(|(node_id, _)| [network_path, &[node_id]].concat()));
});
layer_paths
}

/// The metadata of the network at this path in a legacy document.
/// Older documents keep a held network's metadata inside its node's metadata, newer ones keep a definition's in a table.
fn legacy_network_metadata<'a>(network: &NodeNetwork, document: &'a serde_json::Value, network_path: &[NodeId]) -> Option<&'a serde_json::Value> {
let document_network_metadata = &document["network_interface"]["network_metadata"];
let definitions = &document_network_metadata["persistent_metadata"]["definitions"];

let mut current = network;
let mut network_metadata = document_network_metadata;
for node_id in network_path {
let node = current.nodes.get(node_id)?;
network_metadata = match node.implementation {
DocumentNodeImplementation::Definition(id) => &definitions[id.0.to_string()],
DocumentNodeImplementation::Network(_) => &legacy_node_metadata(network_metadata).remove(node_id)?["network_metadata"],
_ => return None,
};
current = network.implementation_network(&node.implementation)?;
}

Some(network_metadata)
}

/// The metadata of each node in a legacy network, by ID.
fn legacy_node_metadata(network_metadata: &serde_json::Value) -> HashMap<NodeId, &serde_json::Value> {
let entries = network_metadata["persistent_metadata"]["node_metadata"].as_array().into_iter().flatten();
entries.filter_map(|entry| Some((NodeId(entry[0].as_u64()?), &entry[1]["persistent_metadata"]))).collect()
}

#[cfg(test)]
mod tests {
use super::*;
use graph_craft::document::{DocumentNode, NetworkId};

fn node(implementation: DocumentNodeImplementation) -> DocumentNode {
DocumentNode { implementation, ..Default::default() }
}

/// A network holding the nodes 3 and 4.
fn inner_network() -> NodeNetwork {
NodeNetwork {
nodes: [3, 4].map(|id| (NodeId(id), DocumentNode::default())).into_iter().collect(),
..Default::default()
}
}

fn sorted_legacy_layer_paths(network: &NodeNetwork, document: &str) -> Vec<Vec<NodeId>> {
let document = serde_json::from_str(document).expect("The test document should be valid JSON");
let mut layer_paths = legacy_layer_paths(network, &document);
layer_paths.sort();
layer_paths
}

#[test]
fn a_layer_inside_a_definition_is_found_through_each_instance() {
let definition = NetworkId(9);
let network = NodeNetwork {
nodes: [1, 2].map(|id| (NodeId(id), node(DocumentNodeImplementation::Definition(definition)))).into_iter().collect(),
definitions: [(definition, inner_network())].into_iter().collect(),
..Default::default()
};
let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": {
"node_metadata": [[1, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [2, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]],
"definitions": { "9": { "persistent_metadata": {
"node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]]
} } }
} } } }"#;

let expected = vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)], vec![NodeId(2), NodeId(3)]];
assert_eq!(sorted_legacy_layer_paths(&network, document), expected);
}

#[test]
fn a_layer_inside_a_held_network_is_found() {
let network = NodeNetwork {
nodes: [(NodeId(1), node(DocumentNodeImplementation::Network(inner_network())))].into_iter().collect(),
..Default::default()
};
let document = r#"{ "network_interface": { "network_metadata": { "persistent_metadata": {
"node_metadata": [[1, { "persistent_metadata": {
"node_type_metadata": { "Layer": {} },
"network_metadata": { "persistent_metadata": {
"node_metadata": [[3, { "persistent_metadata": { "node_type_metadata": { "Layer": {} } } }], [4, { "persistent_metadata": { "node_type_metadata": { "Node": {} } } }]]
} }
} }]]
} } } }"#;

assert_eq!(sorted_legacy_layer_paths(&network, document), vec![vec![NodeId(1)], vec![NodeId(1), NodeId(3)]]);
}
}
18 changes: 10 additions & 8 deletions editor/src/node_graph_executor/runtime/layer_path_tests.rs
Original file line number Diff line number Diff line change
Expand Up @@ -4,13 +4,16 @@ use crate::messages::portfolio::document::utility_types::network_interface::{Inp
use crate::test_utils::test_prelude::*;
use graphene_std::graphic::extend;

// A layer that ends in no Extend node has its path written onto its whole output, which gives the editor its click targets
fn rectangle() -> DefinitionIdentifier {
DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER)
}

// A layer without an Extend node gets its path written onto its whole output
#[tokio::test]
async fn a_node_shown_as_a_layer_is_traced_back_to() {
async fn a_layer_gets_click_targets() {
let mut editor = EditorTestUtils::create();
editor.new_document().await;
let rectangle = DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER);
let rectangle = editor.create_node_by_name_at(rectangle, 0, 0).await;
let rectangle = editor.create_node_by_name_at(rectangle(), 0, 0).await;
editor
.handle_message(NodeGraphMessage::CreateWire {
output_connector: OutputConnector::node(rectangle, 0),
Expand All @@ -30,14 +33,13 @@ async fn a_node_shown_as_a_layer_is_traced_back_to() {
);
}

// A layer that is itself an Extend node has its path written, from beside it, onto what it's given to add
// A layer that is an Extend node gets its path written onto what it adds
#[tokio::test]
async fn an_extend_node_shown_as_a_layer_is_traced_back_to() {
async fn an_extend_node_layer_gets_click_targets() {
let mut editor = EditorTestUtils::create();
editor.new_document().await;
let extend = editor.create_node_by_name_at(DefinitionIdentifier::ProtoNode(extend::IDENTIFIER), 0, 0).await;
let rectangle = DefinitionIdentifier::ProtoNode(graphene_std::vector::generator_nodes::rectangle::IDENTIFIER);
let (below, added) = (editor.create_node_by_name_at(rectangle.clone(), -10, 0).await, editor.create_node_by_name_at(rectangle, -10, 4).await);
let (below, added) = (editor.create_node_by_name_at(rectangle(), -10, 0).await, editor.create_node_by_name_at(rectangle(), -10, 4).await);
for (rectangle, input) in [(below, InputConnector::node(extend, extend::BaseInput)), (added, InputConnector::node(extend, extend::NewInput))] {
editor
.handle_message(NodeGraphMessage::CreateWire {
Expand Down
Loading
Loading