fix PAP-163

paperclip-ui · Dec 30, 2023 · 0ba6943 · 0ba6943
1 parent 07b1762
commit 0ba6943
Show file tree

Hide file tree

Showing 7 changed files with 63 additions and 25 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/libs/ast_serialize/src/pc.rs b/libs/ast_serialize/src/pc.rs
@@ -37,10 +37,10 @@ pub fn serialize_document(document: &ast::Document, context: &mut Context) {
             ast::document_body_item::Inner::Component(comp) => serialize_component(&comp, context),
             ast::document_body_item::Inner::Style(style) => serialize_style(&style, context),
             ast::document_body_item::Inner::Element(element) => {
-                serialize_element(&element, context)
+                serialize_element(&element, true, context)
             }
             ast::document_body_item::Inner::Trigger(expr) => serialize_trigger(&expr, context),
-            ast::document_body_item::Inner::Text(text) => serialize_text(&text, context),
+            ast::document_body_item::Inner::Text(text) => serialize_text(&text, true, context),
         }
 
         // extra space for document body items
@@ -198,12 +198,12 @@ pub fn serialize_render(imp: &ast::Render, context: &mut Context) {
 
 pub fn serialize_node(node: &ast::Node, context: &mut Context) {
     match node.get_inner() {
-        ast::node::Inner::Element(element) => serialize_element(element, context),
+        ast::node::Inner::Element(element) => serialize_element(element, false, context),
         ast::node::Inner::Slot(slot) => serialize_slot(slot, context),
         ast::node::Inner::Insert(insert) => serialize_insert(insert, context),
         ast::node::Inner::Style(style) => serialize_style(style, context),
         ast::node::Inner::Override(over) => serialize_override(over, context),
-        ast::node::Inner::Text(text) => serialize_text(text, context),
+        ast::node::Inner::Text(text) => serialize_text(text, false, context),
         ast::node::Inner::Script(text) => serialize_script(text, context),
         ast::node::Inner::Condition(expr) => serialize_condition(expr, context),
         ast::node::Inner::Switch(expr) => serialize_switch(expr, context),
@@ -260,9 +260,11 @@ pub fn serialize_repeat(expr: &ast::Repeat, context: &mut Context) {
     context.add_buffer("}\n");
 }
 
-pub fn serialize_text(node: &ast::TextNode, context: &mut Context) {
-    if let Some(comment) = &node.comment {
-        serialize_doc_comment2(comment, context);
+pub fn serialize_text(node: &ast::TextNode, is_root: bool, context: &mut Context) {
+    if is_root {
+        if let Some(comment) = &node.comment {
+            serialize_doc_comment2(comment, context);
+        }
     }
     context.add_buffer("text");
     maybe_serialize_ref_name(&node.name, context);
@@ -282,10 +284,13 @@ pub fn serialize_text(node: &ast::TextNode, context: &mut Context) {
     context.add_buffer("\n");
 }
 
-pub fn serialize_element(node: &ast::Element, context: &mut Context) {
-    if let Some(comment) = &node.comment {
-        serialize_doc_comment2(comment, context);
+pub fn serialize_element(node: &ast::Element, is_root: bool, context: &mut Context) {
+    if is_root {
+        if let Some(comment) = &node.comment {
+            serialize_doc_comment2(comment, context);
+        }
     }
+
     if let Some(namespace) = &node.namespace {
         context.add_buffer(format!("{}.", namespace).as_str());
     }

diff --git a/libs/ast_serialize/src/serializable.rs b/libs/ast_serialize/src/serializable.rs
@@ -21,8 +21,8 @@ impl Serializable for ExpressionWrapper {
             ExpressionWrapper::Boolean(expr) => serialize_boolean(expr, &mut context),
             ExpressionWrapper::Comment(expr) => serialize_doc_comment2(expr, &mut context),
             ExpressionWrapper::Component(expr) => serialize_component(expr, &mut context),
-            ExpressionWrapper::Element(expr) => serialize_element(expr, &mut context),
-            ExpressionWrapper::TextNode(expr) => serialize_text(expr, &mut context),
+            ExpressionWrapper::Element(expr) => serialize_element(expr, false, &mut context),
+            ExpressionWrapper::TextNode(expr) => serialize_text(expr, false, &mut context),
             ExpressionWrapper::Node(expr) => serialize_node(expr, &mut context),
             ExpressionWrapper::Slot(expr) => serialize_slot(expr, &mut context),
             ExpressionWrapper::Insert(expr) => serialize_insert(expr, &mut context),

diff --git a/libs/designer/src/ui/theme.pc b/libs/designer/src/ui/theme.pc
@@ -50,7 +50,6 @@ public token roundedSM 0.125rem
 public token rounded 0.25rem
 public token roundedMD 0.375rem
 public token inputHeight 24px
-
 public style mask {
     background-color: currentColor
     -webkit-mask-size: 100%
@@ -132,3 +131,19 @@ public style centered {
 trigger mobile {
     "@media screen and (max-width: 480px)"
 }
+
+
+/**
+ * @frame(x: 15, y: -130, width: 1024, height: 768)
+*/
+div {
+    style {
+        background: blue
+    }
+    div {
+        style {
+            background: blue
+        }
+    }
+}
+
diff --git a/libs/validate/src/print.rs b/libs/validate/src/print.rs
@@ -174,6 +174,10 @@ impl ToString for PrettyPrint {
     }
 }
 
+pub trait PrintPrettyError {
+    fn print_pretty_error(&self);
+}
+
 pub trait ToPrettyString {
     fn to_pretty_string(&self) -> String;
 }
@@ -190,3 +194,11 @@ impl ToPrettyString for NoticeList {
         return pretty.to_string();
     }
 }
+
+impl<Expr> PrintPrettyError for Result<Expr, NoticeList> {
+    fn print_pretty_error(&self) {
+        if let Err(err) = self {
+            println!("{}", err.to_pretty_string());
+        }
+    }
+}
diff --git a/libs/workspace/Cargo.toml b/libs/workspace/Cargo.toml
@@ -27,6 +27,7 @@ local = [
 paperclip_project = { path = "../project", features = [] }
 paperclip_proto = { path = "../proto", features = ["transport"] }
 paperclip_proto_ext = { path = "../proto_ext", features = [] }
+paperclip_validate = { path = "../validate" }
 tonic = { version = "0.10.2" }
 tonic-web = "0.10.2"
 prost = "0.11.0"

diff --git a/libs/workspace/src/server/domains/paperclip/engine.rs b/libs/workspace/src/server/domains/paperclip/engine.rs
@@ -4,6 +4,8 @@ use anyhow::Result;
 use paperclip_common::log::verbose;
 use paperclip_evaluator::core::io::PCFileResolver;
 use paperclip_evaluator::css;
+use paperclip_proto::notice::base::NoticeList;
+use paperclip_validate::print::PrintPrettyError;
 
 use futures::executor::block_on;
 use paperclip_common::fs::{FileReader, FileResolver};
@@ -31,34 +33,34 @@ async fn handle_events<TIO: ServerIO>(ctx: ServerEngineContext<TIO>) {
     handle_store_events!(
         &ctx.store,
         ServerEvent::PaperclipFilesLoaded { files } => {
-            load_dependency_graph(next.clone(), &files).await.expect("Unable to load dependency graph");
+            load_dependency_graph(next.clone(), &files).await.print_pretty_error();
         },
         ServerEvent::FileMoved { from_path, to_path } => {
-            move_pc_file(ctx.clone(), from_path, to_path).await.expect("Unable to update refs");
+            let _ = move_pc_file(ctx.clone(), from_path, to_path).await;
         },
         ServerEvent::DependencyGraphLoaded { graph } => {
             evaluate_dependency_graph(next.clone(), Some(graph.dependencies.keys().map(|k| {
                 k.to_string()
-            }).collect())).await.expect("Unable to evaluate Dependency graph");
+            }).collect())).await.print_pretty_error();
         },
         ServerEvent::GlobalScriptsLoaded(_) => {
-            evaluate_dependency_graph(next.clone(), None).await.expect("Unable to evaluate Dependency graph");
+            evaluate_dependency_graph(next.clone(), None).await.print_pretty_error();
         },
         ServerEvent::UpdateFileRequested { path: _path, content: _content } => {
             let updated_files = next.clone().store.lock().unwrap().state.updated_files.clone();
 
             verbose(&format!("Updated files {:?}", updated_files));
 
             for update_file in updated_files {
-                load_dependency_graph(next.clone(), &vec![update_file]).await.expect("Unable to load dependency");
+                load_dependency_graph(next.clone(), &vec![update_file]).await.print_pretty_error();
             }
         },
         ServerEvent::MutationsApplied {result: _, updated_graph: _} | ServerEvent::UndoRequested | ServerEvent::RedoRequested  => {
-            evaluate_dependency_graph(next.clone(), None).await.expect("Unable to evaluate Dependency graph");
+            evaluate_dependency_graph(next.clone(), None).await.print_pretty_error();
         },
         ServerEvent::FileWatchEvent(event) => {
             if paperclip_common::pc::is_paperclip_file(&event.path) {
-                load_pc_file(next.clone(), &event.path).await.expect(format!("Unable to evaluate file {}", event.path).as_str());
+                load_pc_file(next.clone(), &event.path).await.print_pretty_error();
             }
         }
     );
@@ -110,7 +112,7 @@ impl<TIO: ServerIO> FileResolver for VirtGraphIO<TIO> {
 async fn load_dependency_graph<TIO: ServerIO>(
     ctx: ServerEngineContext<TIO>,
     files: &Vec<String>,
-) -> Result<()> {
+) -> Result<(), NoticeList> {
     let graph = ctx.store.lock().unwrap().state.graph.clone();
     let parse_options = ctx
         .store
@@ -132,7 +134,10 @@ async fn load_dependency_graph<TIO: ServerIO>(
     Ok(())
 }
 
-async fn load_pc_file<TIO: ServerIO>(ctx: ServerEngineContext<TIO>, file: &str) -> Result<()> {
+async fn load_pc_file<TIO: ServerIO>(
+    ctx: ServerEngineContext<TIO>,
+    file: &str,
+) -> Result<(), NoticeList> {
     verbose(&format!("load_pc_file {:?}", file));
 
     let graph = ctx.store.lock().unwrap().state.graph.clone();
@@ -188,8 +193,7 @@ async fn move_pc_file<TIO: ServerIO>(
         .get_outer()],
         ctx.clone(),
     )
-    .await
-    .expect("Could not update imports");
+    .await?;
 
     ctx.emit(ServerEvent::MutationsInternallyApplied);
 
@@ -199,7 +203,7 @@ async fn move_pc_file<TIO: ServerIO>(
 async fn evaluate_dependency_graph<TIO: ServerIO>(
     ctx: ServerEngineContext<TIO>,
     files: Option<Vec<String>>,
-) -> Result<()> {
+) -> Result<(), NoticeList> {
     let files = if let Some(files) = files {
         files
     } else {