Remove all references to legacy layers (#1523)

* Remove visible field from LegacyLayer

* Remove LegacyLayer wrapper around LegacyLayerType

* Remove FolderLegacyLayer and LayerLegacyLayer wrappers around their data

* Remove legacy layers

Author: Keavon

document-legacy/src/document.rs

@@ -1,7 +1,4 @@
 use crate::document_metadata::{is_artboard, DocumentMetadata, LayerNodeIdentifier};
-use crate::layers::folder_layer::FolderLegacyLayer;
-use crate::layers::layer_info::{LegacyLayer, LegacyLayerType};
-use crate::DocumentError;
 
 use graph_craft::document::{DocumentNode, DocumentNodeImplementation, NodeId, NodeNetwork, NodeOutput};
 use graphene_core::renderer::ClickTarget;
@@ -23,9 +20,6 @@ pub type LayerId = u64;
 pub struct Document {
 	#[serde(default)]
 	pub document_network: NodeNetwork,
-	/// The root layer, usually a [FolderLegacyLayer](layers::folder_layer::FolderLegacyLayer) that contains all other [LegacyLayers](layers::layer_info::LegacyLayer).
-	#[serde(skip)]
-	pub root: LegacyLayer,
 	/// The state_identifier serves to provide a way to uniquely identify a particular state that the document is in.
 	/// This identifier is not a hash and is not guaranteed to be equal for equivalent documents.
 	#[serde(skip)]
@@ -43,11 +37,6 @@ impl PartialEq for Document {
 impl Default for Document {
 	fn default() -> Self {
 		Self {
-			root: LegacyLayer {
-				name: None,
-				visible: true,
-				data: LegacyLayerType::Folder(FolderLegacyLayer::default()),
-			},
 			state_identifier: DefaultHasher::new(),
 			document_network: {
 				use graph_craft::document::{value::TaggedValue, NodeInput};
@@ -156,100 +145,4 @@ impl Document {
 	pub fn current_state_identifier(&self) -> u64 {
 		self.state_identifier.finish()
 	}
-
-	/// Returns a reference to the requested folder. Fails if the path does not exist,
-	/// or if the requested layer is not of type folder.
-	pub fn folder(&self, path: impl AsRef<[LayerId]>) -> Result<&FolderLegacyLayer, DocumentError> {
-		let mut root = &self.root;
-		for id in path.as_ref() {
-			root = root.as_folder()?.layer(*id).ok_or_else(|| DocumentError::LayerNotFound(path.as_ref().into()))?;
-		}
-		root.as_folder()
-	}
-
-	/// Returns a mutable reference to the requested folder. Fails if the path does not exist,
-	/// or if the requested layer is not of type folder.
-	fn folder_mut(&mut self, path: &[LayerId]) -> Result<&mut FolderLegacyLayer, DocumentError> {
-		let mut root = &mut self.root;
-		for id in path {
-			root = root.as_folder_mut()?.layer_mut(*id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))?;
-		}
-		root.as_folder_mut()
-	}
-
-	/// Returns a reference to the layer or folder at the path.
-	pub fn layer(&self, path: &[LayerId]) -> Result<&LegacyLayer, DocumentError> {
-		if path.is_empty() {
-			return Ok(&self.root);
-		}
-		let (path, id) = split_path(path)?;
-		self.folder(path)?.layer(id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))
-	}
-
-	/// Returns a mutable reference to the layer or folder at the path.
-	pub fn layer_mut(&mut self, path: &[LayerId]) -> Result<&mut LegacyLayer, DocumentError> {
-		if path.is_empty() {
-			return Ok(&mut self.root);
-		}
-		let (path, id) = split_path(path)?;
-		self.folder_mut(path)?.layer_mut(id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))
-	}
-
-	pub fn common_layer_path_prefix<'a>(&self, layers: impl Iterator<Item = &'a [LayerId]>) -> &'a [LayerId] {
-		layers.reduce(|a, b| &a[..a.iter().zip(b.iter()).take_while(|&(a, b)| a == b).count()]).unwrap_or_default()
-	}
-
-	/// Returns the shallowest folder given the selection, even if the selection doesn't contain any folders
-	pub fn shallowest_common_folder<'a>(&self, layers: impl Iterator<Item = &'a [LayerId]>) -> Result<&'a [LayerId], DocumentError> {
-		let common_prefix_of_path = self.common_layer_path_prefix(layers);
-
-		Ok(match self.layer(common_prefix_of_path)?.data {
-			LegacyLayerType::Folder(_) => common_prefix_of_path,
-			_ => &common_prefix_of_path[..common_prefix_of_path.len() - 1],
-		})
-	}
-
-	/// Returns all layers that are not contained in any other of the given folders
-	/// Takes and Iterator over &[LayerId] or &Vec<LayerId>.
-	pub fn shallowest_unique_layers<'a, T>(layers: impl Iterator<Item = T>) -> Vec<T>
-	where
-		T: AsRef<[LayerId]> + std::cmp::Ord + 'a,
-	{
-		let mut sorted_layers: Vec<_> = layers.collect();
-		sorted_layers.sort();
-		// Sorting here creates groups of similar UUID paths
-		sorted_layers.dedup_by(|a, b| a.as_ref().starts_with(b.as_ref()));
-		sorted_layers
-	}
-
-	/// Given a path to a layer, returns a vector of the indices in the layer tree
-	/// These indices can be used to order a list of layers
-	pub fn indices_for_path(&self, path: &[LayerId]) -> Result<Vec<usize>, DocumentError> {
-		let mut root = self.root.as_folder()?;
-		let mut indices = vec![];
-		let (path, layer_id) = split_path(path)?;
-
-		// TODO: appears to be n^2? should we maintain a lookup table?
-		for id in path {
-			let pos = root.layer_ids.iter().position(|x| *x == *id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))?;
-			indices.push(pos);
-			root = match root.layer(*id) {
-				Some(LegacyLayer {
-					data: LegacyLayerType::Folder(folder),
-					..
-				}) => Some(folder),
-				_ => None,
-			}
-			.ok_or_else(|| DocumentError::LayerNotFound(path.into()))?;
-		}
-
-		indices.push(root.layer_ids.iter().position(|x| *x == layer_id).ok_or_else(|| DocumentError::LayerNotFound(path.into()))?);
-
-		Ok(indices)
-	}
-}
-
-fn split_path(path: &[LayerId]) -> Result<(&[LayerId], LayerId), DocumentError> {
-	let (id, path) = path.split_last().ok_or(DocumentError::InvalidPath)?;
-	Ok((path, *id))
 }

document-legacy/src/document_metadata.rs

@@ -154,24 +154,20 @@ impl DocumentMetadata {
 
 // selected layer modifications
 impl DocumentMetadata {
-	#[must_use]
-	pub fn retain_selected_nodes(&mut self, f: impl FnMut(&NodeId) -> bool) -> SelectionChanged {
+	pub fn retain_selected_nodes(&mut self, f: impl FnMut(&NodeId) -> bool) {
 		self.selected_nodes.retain(f);
-		SelectionChanged
 	}
-	#[must_use]
-	pub fn set_selected_nodes(&mut self, new: Vec<NodeId>) -> SelectionChanged {
+
+	pub fn set_selected_nodes(&mut self, new: Vec<NodeId>) {
 		self.selected_nodes = new;
-		SelectionChanged
 	}
-	#[must_use]
-	pub fn add_selected_nodes(&mut self, iter: impl IntoIterator<Item = NodeId>) -> SelectionChanged {
+
+	pub fn add_selected_nodes(&mut self, iter: impl IntoIterator<Item = NodeId>) {
 		self.selected_nodes.extend(iter);
-		SelectionChanged
 	}
-	#[must_use]
-	pub fn clear_selected_nodes(&mut self) -> SelectionChanged {
-		self.set_selected_nodes(Vec::new())
+
+	pub fn clear_selected_nodes(&mut self) {
+		self.set_selected_nodes(Vec::new());
 	}
 
 	/// Loads the structure of layer nodes from a node graph.
@@ -374,8 +370,8 @@ impl LayerNodeIdentifier {
 	#[track_caller]
 	pub fn new(node_id: NodeId, network: &NodeNetwork) -> Self {
 		debug_assert!(
-			is_layer_node(node_id, network),
-			"Layer identifier constructed from non layer node {node_id}: {:#?}",
+			node_id == LayerNodeIdentifier::ROOT.to_node() || network.nodes.get(&node_id).is_some_and(|node| node.is_layer()),
+			"Layer identifier constructed from non-layer node {node_id}: {:#?}",
 			network.nodes.get(&node_id)
 		);
 		Self::new_unchecked(node_id)
@@ -633,10 +629,6 @@ pub struct NodeRelations {
 	last_child: Option<LayerNodeIdentifier>,
 }
 
-fn is_layer_node(node: NodeId, network: &NodeNetwork) -> bool {
-	node == LayerNodeIdentifier::ROOT.to_node() || network.nodes.get(&node).is_some_and(|node| node.is_layer())
-}
-
 #[test]
 fn test_tree() {
 	let mut document_metadata = DocumentMetadata::default();

document-legacy/src/layers/folder_layer.rs

@@ -1,16 +1,2 @@
-// `macro_use` puts the log macros (`error!`, `warn!`, `debug!`, `info!` and `trace!`) in scope for the crate
-// #[macro_use]
-extern crate log;
-
 pub mod document;
 pub mod document_metadata;
-pub mod layers;
-
-/// A set of different errors that can occur when using this crate.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DocumentError {
-	LayerNotFound(Vec<document::LayerId>),
-	InvalidPath,
-	NotFolder,
-	InvalidFile(String),
-}