Massively reorganize and clean up the whole Rust codebase (#478)

* Massively reorganize and clean up the whole Rust codebase

* Additional changes during code review

graphene/src/color.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-/// Structure that represent a color.
+/// Structure that represents a color.
 /// Internally alpha is stored as `f32` that ranges from `0.0` (transparent) to `1.0` (opaque).
 /// The other components (RGB) are stored as `f32` that range from `0.0` up to `f32::MAX`,
 /// the values encode the brightness of each channel proportional to the light intensity in cd/m² (nits) in HDR, and `0.0` (black) to `1.0` (white) in SDR color.

graphene/src/document.rs

@@ -1,16 +1,18 @@
-use std::{
-	cmp::max,
-	collections::hash_map::DefaultHasher,
-	hash::{Hash, Hasher},
-};
+use crate::intersection::Quad;
+use crate::layers;
+use crate::layers::folder::Folder;
+use crate::layers::layer_info::{Layer, LayerData, LayerDataType};
+use crate::layers::simple_shape::Shape;
+use crate::layers::style::ViewMode;
+use crate::{DocumentError, DocumentResponse, Operation};
 
 use glam::{DAffine2, DVec2};
 use serde::{Deserialize, Serialize};
+use std::cmp::max;
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
 
-use crate::{
-	layers::{self, style::ViewMode, Folder, Layer, LayerData, LayerDataType, Shape},
-	DocumentError, DocumentResponse, LayerId, Operation, Quad,
-};
+pub type LayerId = u64;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Document {

graphene/src/error.rs

@@ -0,0 +1,12 @@
+use super::LayerId;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum DocumentError {
+	LayerNotFound(Vec<LayerId>),
+	InvalidPath,
+	IndexOutOfBounds,
+	NotAFolder,
+	NonReorderableSelection,
+	NotAShape,
+	InvalidFile(String),
+}

graphene/src/intersection.rs

@@ -1,7 +1,6 @@
-use std::ops::Mul;
-
 use glam::{DAffine2, DVec2};
 use kurbo::{BezPath, Line, PathSeg, Point, Shape};
+use std::ops::Mul;
 
 #[derive(Debug, Clone, Default, Copy)]
 pub struct Quad([DVec2; 4]);

graphene/src/layers/folder.rs

@@ -1,9 +1,9 @@
+use super::layer_info::{Layer, LayerData, LayerDataType};
+use super::style::ViewMode;
+use crate::intersection::Quad;
+use crate::{DocumentError, LayerId};
+
 use glam::DVec2;
-
-use crate::{layers::style::ViewMode, DocumentError, LayerId, Quad};
-
-use super::{Layer, LayerData, LayerDataType};
-
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
 

graphene/src/layers/layer_info.rs

@@ -0,0 +1,208 @@
+use super::blend_mode::BlendMode;
+use super::folder::Folder;
+use super::simple_shape::Shape;
+use super::style::ViewMode;
+use crate::intersection::Quad;
+use crate::DocumentError;
+use crate::LayerId;
+
+use glam::{DAffine2, DMat2, DVec2};
+use serde::{Deserialize, Serialize};
+use std::fmt::Write;
+
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
+pub enum LayerDataType {
+	Folder(Folder),
+	Shape(Shape),
+}
+
+impl LayerDataType {
+	pub fn inner(&self) -> &dyn LayerData {
+		match self {
+			LayerDataType::Shape(s) => s,
+			LayerDataType::Folder(f) => f,
+		}
+	}
+
+	pub fn inner_mut(&mut self) -> &mut dyn LayerData {
+		match self {
+			LayerDataType::Shape(s) => s,
+			LayerDataType::Folder(f) => f,
+		}
+	}
+}
+
+pub trait LayerData {
+	fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode);
+	fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>);
+	fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]>;
+}
+
+impl LayerData for LayerDataType {
+	fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode) {
+		self.inner_mut().render(svg, transforms, view_mode)
+	}
+
+	fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
+		self.inner().intersects_quad(quad, path, intersections)
+	}
+
+	fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {
+		self.inner().bounding_box(transform)
+	}
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "glam::DAffine2")]
+struct DAffine2Ref {
+	pub matrix2: DMat2,
+	pub translation: DVec2,
+}
+
+fn return_true() -> bool {
+	true
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+pub struct Layer {
+	pub visible: bool,
+	pub name: Option<String>,
+	pub data: LayerDataType,
+	#[serde(with = "DAffine2Ref")]
+	pub transform: glam::DAffine2,
+	#[serde(skip)]
+	pub cache: String,
+	#[serde(skip)]
+	pub thumbnail_cache: String,
+	#[serde(skip, default = "return_true")]
+	pub cache_dirty: bool,
+	pub blend_mode: BlendMode,
+	pub opacity: f64,
+}
+
+impl Layer {
+	pub fn new(data: LayerDataType, transform: [f64; 6]) -> Self {
+		Self {
+			visible: true,
+			name: None,
+			data,
+			transform: glam::DAffine2::from_cols_array(&transform),
+			cache: String::new(),
+			thumbnail_cache: String::new(),
+			cache_dirty: true,
+			blend_mode: BlendMode::Normal,
+			opacity: 1.,
+		}
+	}
+
+	pub fn iter(&self) -> LayerIter<'_> {
+		LayerIter { stack: vec![self] }
+	}
+
+	pub fn render(&mut self, transforms: &mut Vec<DAffine2>, view_mode: ViewMode) -> &str {
+		if !self.visible {
+			return "";
+		}
+
+		if self.cache_dirty {
+			transforms.push(self.transform);
+			self.thumbnail_cache.clear();
+			self.data.render(&mut self.thumbnail_cache, transforms, view_mode);
+
+			self.cache.clear();
+			let _ = writeln!(self.cache, r#"<g transform="matrix("#);
+			self.transform.to_cols_array().iter().enumerate().for_each(|(i, f)| {
+				let _ = self.cache.write_str(&(f.to_string() + if i != 5 { "," } else { "" }));
+			});
+			let _ = write!(
+				self.cache,
+				r#")" style="mix-blend-mode: {}; opacity: {}">{}</g>"#,
+				self.blend_mode.to_svg_style_name(),
+				self.opacity,
+				self.thumbnail_cache.as_str()
+			);
+			transforms.pop();
+			self.cache_dirty = false;
+		}
+
+		self.cache.as_str()
+	}
+
+	pub fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
+		if !self.visible {
+			return;
+		}
+
+		let transformed_quad = self.transform.inverse() * quad;
+		self.data.intersects_quad(transformed_quad, path, intersections)
+	}
+
+	pub fn current_bounding_box_with_transform(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
+		self.data.bounding_box(transform)
+	}
+
+	pub fn current_bounding_box(&self) -> Option<[DVec2; 2]> {
+		self.current_bounding_box_with_transform(self.transform)
+	}
+
+	pub fn as_folder_mut(&mut self) -> Result<&mut Folder, DocumentError> {
+		match &mut self.data {
+			LayerDataType::Folder(f) => Ok(f),
+			_ => Err(DocumentError::NotAFolder),
+		}
+	}
+
+	pub fn as_folder(&self) -> Result<&Folder, DocumentError> {
+		match &self.data {
+			LayerDataType::Folder(f) => Ok(f),
+			_ => Err(DocumentError::NotAFolder),
+		}
+	}
+}
+
+impl Clone for Layer {
+	fn clone(&self) -> Self {
+		Self {
+			visible: self.visible,
+			name: self.name.clone(),
+			data: self.data.clone(),
+			transform: self.transform,
+			cache: String::new(),
+			thumbnail_cache: String::new(),
+			cache_dirty: true,
+			blend_mode: self.blend_mode,
+			opacity: self.opacity,
+		}
+	}
+}
+
+impl<'a> IntoIterator for &'a Layer {
+	type Item = &'a Layer;
+	type IntoIter = LayerIter<'a>;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.iter()
+	}
+}
+
+#[derive(Debug, Default)]
+pub struct LayerIter<'a> {
+	pub stack: Vec<&'a Layer>,
+}
+
+impl<'a> Iterator for LayerIter<'a> {
+	type Item = &'a Layer;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		match self.stack.pop() {
+			Some(layer) => {
+				if let LayerDataType::Folder(folder) = &layer.data {
+					let layers = folder.layers();
+					self.stack.extend(layers);
+				};
+				Some(layer)
+			}
+			None => None,
+		}
+	}
+}

graphene/src/layers/mod.rs

@@ -1,212 +1,5 @@
-pub mod style;
-use style::ViewMode;
-
-use glam::DAffine2;
-use glam::{DMat2, DVec2};
-
 pub mod blend_mode;
-pub use blend_mode::BlendMode;
-
-pub mod simple_shape;
-pub use simple_shape::Shape;
-
 pub mod folder;
-use crate::LayerId;
-use crate::{DocumentError, Quad};
-pub use folder::Folder;
-use serde::{Deserialize, Serialize};
-
-use std::fmt::Write;
-
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub enum LayerDataType {
-	Folder(Folder),
-	Shape(Shape),
-}
-impl LayerDataType {
-	pub fn inner(&self) -> &dyn LayerData {
-		match self {
-			LayerDataType::Shape(s) => s,
-			LayerDataType::Folder(f) => f,
-		}
-	}
-
-	pub fn inner_mut(&mut self) -> &mut dyn LayerData {
-		match self {
-			LayerDataType::Shape(s) => s,
-			LayerDataType::Folder(f) => f,
-		}
-	}
-}
-
-pub trait LayerData {
-	fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode);
-	fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>);
-	fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]>;
-}
-
-impl LayerData for LayerDataType {
-	fn render(&mut self, svg: &mut String, transforms: &mut Vec<glam::DAffine2>, view_mode: ViewMode) {
-		self.inner_mut().render(svg, transforms, view_mode)
-	}
-
-	fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
-		self.inner().intersects_quad(quad, path, intersections)
-	}
-
-	fn bounding_box(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {
-		self.inner().bounding_box(transform)
-	}
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "glam::DAffine2")]
-struct DAffine2Ref {
-	pub matrix2: DMat2,
-	pub translation: DVec2,
-}
-
-fn return_true() -> bool {
-	true
-}
-
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
-pub struct Layer {
-	pub visible: bool,
-	pub name: Option<String>,
-	pub data: LayerDataType,
-	#[serde(with = "DAffine2Ref")]
-	pub transform: glam::DAffine2,
-	#[serde(skip)]
-	pub cache: String,
-	#[serde(skip)]
-	pub thumbnail_cache: String,
-	#[serde(skip, default = "return_true")]
-	pub cache_dirty: bool,
-	pub blend_mode: BlendMode,
-	pub opacity: f64,
-}
-
-impl Layer {
-	pub fn new(data: LayerDataType, transform: [f64; 6]) -> Self {
-		Self {
-			visible: true,
-			name: None,
-			data,
-			transform: glam::DAffine2::from_cols_array(&transform),
-			cache: String::new(),
-			thumbnail_cache: String::new(),
-			cache_dirty: true,
-			blend_mode: BlendMode::Normal,
-			opacity: 1.,
-		}
-	}
-
-	pub fn iter(&self) -> LayerIter<'_> {
-		LayerIter { stack: vec![self] }
-	}
-
-	pub fn render(&mut self, transforms: &mut Vec<DAffine2>, view_mode: ViewMode) -> &str {
-		if !self.visible {
-			return "";
-		}
-		if self.cache_dirty {
-			transforms.push(self.transform);
-			self.thumbnail_cache.clear();
-			self.data.render(&mut self.thumbnail_cache, transforms, view_mode);
-
-			self.cache.clear();
-			let _ = writeln!(self.cache, r#"<g transform="matrix("#);
-			self.transform.to_cols_array().iter().enumerate().for_each(|(i, f)| {
-				let _ = self.cache.write_str(&(f.to_string() + if i != 5 { "," } else { "" }));
-			});
-			let _ = write!(
-				self.cache,
-				r#")" style="mix-blend-mode: {}; opacity: {}">{}</g>"#,
-				self.blend_mode.to_svg_style_name(),
-				self.opacity,
-				self.thumbnail_cache.as_str()
-			);
-			transforms.pop();
-			self.cache_dirty = false;
-		}
-		self.cache.as_str()
-	}
-
-	pub fn intersects_quad(&self, quad: Quad, path: &mut Vec<LayerId>, intersections: &mut Vec<Vec<LayerId>>) {
-		if !self.visible {
-			return;
-		}
-		let transformed_quad = self.transform.inverse() * quad;
-		self.data.intersects_quad(transformed_quad, path, intersections)
-	}
-
-	pub fn current_bounding_box_with_transform(&self, transform: DAffine2) -> Option<[DVec2; 2]> {
-		self.data.bounding_box(transform)
-	}
-
-	pub fn current_bounding_box(&self) -> Option<[DVec2; 2]> {
-		self.current_bounding_box_with_transform(self.transform)
-	}
-
-	pub fn as_folder_mut(&mut self) -> Result<&mut Folder, DocumentError> {
-		match &mut self.data {
-			LayerDataType::Folder(f) => Ok(f),
-			_ => Err(DocumentError::NotAFolder),
-		}
-	}
-
-	pub fn as_folder(&self) -> Result<&Folder, DocumentError> {
-		match &self.data {
-			LayerDataType::Folder(f) => Ok(f),
-			_ => Err(DocumentError::NotAFolder),
-		}
-	}
-}
-
-impl Clone for Layer {
-	fn clone(&self) -> Self {
-		Self {
-			visible: self.visible,
-			name: self.name.clone(),
-			data: self.data.clone(),
-			transform: self.transform,
-			cache: String::new(),
-			thumbnail_cache: String::new(),
-			cache_dirty: true,
-			blend_mode: self.blend_mode,
-			opacity: self.opacity,
-		}
-	}
-}
-
-impl<'a> IntoIterator for &'a Layer {
-	type Item = &'a Layer;
-	type IntoIter = LayerIter<'a>;
-
-	fn into_iter(self) -> Self::IntoIter {
-		self.iter()
-	}
-}
-
-#[derive(Debug, Default)]
-pub struct LayerIter<'a> {
-	pub stack: Vec<&'a Layer>,
-}
-
-impl<'a> Iterator for LayerIter<'a> {
-	type Item = &'a Layer;
-
-	fn next(&mut self) -> Option<Self::Item> {
-		match self.stack.pop() {
-			Some(layer) => {
-				if let LayerDataType::Folder(folder) = &layer.data {
-					let layers = folder.layers();
-					self.stack.extend(layers);
-				};
-				Some(layer)
-			}
-			None => None,
-		}
-	}
-}
+pub mod layer_info;
+pub mod simple_shape;
+pub mod style;

graphene/src/layers/simple_shape.rs

@@ -1,19 +1,10 @@
-use glam::DAffine2;
-use glam::DMat2;
-use glam::DVec2;
-use kurbo::Affine;
-use kurbo::BezPath;
-use kurbo::Shape as KurboShape;
-
-use crate::intersection::intersect_quad_bez_path;
-use crate::layers::{
-	style,
-	style::{PathStyle, ViewMode},
-	LayerData,
-};
+use super::layer_info::LayerData;
+use super::style::{self, PathStyle, ViewMode};
+use crate::intersection::{intersect_quad_bez_path, Quad};
 use crate::LayerId;
-use crate::Quad;
 
+use glam::{DAffine2, DMat2, DVec2};
+use kurbo::{Affine, BezPath, Shape as KurboShape};
 use serde::{Deserialize, Serialize};
 use std::fmt::Write;
 
@@ -107,6 +98,7 @@ impl Shape {
 		relative_points.for_each(|p| path.line_to(p));
 
 		path.close_path();
+
 		Self {
 			path,
 			style,
@@ -146,6 +138,7 @@ impl Shape {
 			.map(|v: DVec2| kurbo::Point { x: v.x, y: v.y })
 			.enumerate()
 			.for_each(|(i, p)| if i == 0 { path.move_to(p) } else { path.line_to(p) });
+
 		Self {
 			path,
 			style,

graphene/src/layers/style/mod.rs

@@ -1,5 +1,6 @@
 use crate::color::Color;
 use crate::consts::{LAYER_OUTLINE_STROKE_COLOR, LAYER_OUTLINE_STROKE_WIDTH};
+
 use serde::{Deserialize, Serialize};
 
 const OPACITY_PRECISION: usize = 3;
@@ -18,6 +19,7 @@ pub enum ViewMode {
 	Outline,
 	Pixels,
 }
+
 impl Default for ViewMode {
 	fn default() -> Self {
 		ViewMode::Normal
@@ -29,16 +31,20 @@ impl Default for ViewMode {
 pub struct Fill {
 	color: Option<Color>,
 }
+
 impl Fill {
 	pub fn new(color: Color) -> Self {
 		Self { color: Some(color) }
 	}
+
 	pub fn color(&self) -> Option<Color> {
 		self.color
 	}
+
 	pub const fn none() -> Self {
 		Self { color: None }
 	}
+
 	pub fn render(&self) -> String {
 		match self.color {
 			Some(c) => format!(r##" fill="#{}"{}"##, c.rgb_hex(), format_opacity("fill", c.a())),
@@ -58,12 +64,15 @@ impl Stroke {
 	pub const fn new(color: Color, width: f32) -> Self {
 		Self { color, width }
 	}
+
 	pub fn color(&self) -> Color {
 		self.color
 	}
+
 	pub fn width(&self) -> f32 {
 		self.width
 	}
+
 	pub fn render(&self) -> String {
 		format!(r##" stroke="#{}"{} stroke-width="{}""##, self.color.rgb_hex(), format_opacity("stroke", self.color.a()), self.width)
 	}
@@ -75,25 +84,32 @@ pub struct PathStyle {
 	stroke: Option<Stroke>,
 	fill: Option<Fill>,
 }
+
 impl PathStyle {
 	pub fn new(stroke: Option<Stroke>, fill: Option<Fill>) -> Self {
 		Self { stroke, fill }
 	}
+
 	pub fn fill(&self) -> Option<Fill> {
 		self.fill
 	}
+
 	pub fn stroke(&self) -> Option<Stroke> {
 		self.stroke
 	}
+
 	pub fn set_fill(&mut self, fill: Fill) {
 		self.fill = Some(fill);
 	}
+
 	pub fn set_stroke(&mut self, stroke: Stroke) {
 		self.stroke = Some(stroke);
 	}
+
 	pub fn clear_fill(&mut self) {
 		self.fill = None;
 	}
+
 	pub fn clear_stroke(&mut self) {
 		self.stroke = None;
 	}
@@ -109,6 +125,7 @@ impl PathStyle {
 			(_, Some(stroke)) => stroke.render(),
 			(_, None) => String::new(),
 		};
+
 		format!("{}{}", fill_attribute, stroke_attribute)
 	}
 }

graphene/src/lib.rs

@@ -1,24 +1,13 @@
 pub mod color;
 pub mod consts;
 pub mod document;
+pub mod error;
 pub mod intersection;
 pub mod layers;
 pub mod operation;
 pub mod response;
 
-pub use intersection::Quad;
+pub use document::LayerId;
+pub use error::DocumentError;
 pub use operation::Operation;
 pub use response::DocumentResponse;
-
-pub type LayerId = u64;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum DocumentError {
-	LayerNotFound(Vec<LayerId>),
-	InvalidPath,
-	IndexOutOfBounds,
-	NotAFolder,
-	NonReorderableSelection,
-	NotAShape,
-	InvalidFile(String),
-}

graphene/src/operation.rs

@@ -1,15 +1,12 @@
-use std::{
-	collections::hash_map::DefaultHasher,
-	hash::{Hash, Hasher},
-};
-
-use crate::{
-	color::Color,
-	layers::{style, BlendMode, Layer},
-	LayerId,
-};
+use crate::color::Color;
+use crate::layers::blend_mode::BlendMode;
+use crate::layers::layer_info::Layer;
+use crate::layers::style;
+use crate::LayerId;
 
 use serde::{Deserialize, Serialize};
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
 
 #[repr(C)]
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]

graphene/src/response.rs

@@ -1,4 +1,5 @@
 use crate::LayerId;
+
 use serde::{Deserialize, Serialize};
 use std::fmt;