update the molding on insertion behavior and change the grouting around a newline

green726 · green726 · commit e231d5deb3f1 · 2025-05-01T14:23:15.000-04:00
diff --git a/src/core/parser/Grouter.re b/src/core/parser/Grouter.re
@@ -8,7 +8,21 @@ let rec split_cell_padding = (~side: Dir.t, c: Cell.t) =>
   switch (Cell.get(c)) {
   | None => Cell.(empty, c)
   | Some(m) when Option.is_some(Meld.Space.get(m)) =>
-    Cell.Space.split(~side, c) |> Option.value(~default=(c, Cell.empty))
+    switch (Cell.Space.split(~side, c)) {
+    | Some(s) => s
+    | None =>
+      // P.show("Cell.space.split results in none with c:", Cell.show(c));
+      switch (side) {
+      | L =>
+        // P.show("split_cell_padding edge left c", Cell.show(c));
+        (c, Cell.empty) /*  |> Option.value(~default=) */
+      | R =>
+        let (c, rest) = Cell.split_edge(~side=L, c);
+        // P.show("split_cell_padding split_edge right c", Cell.show(c));
+        // P.show("rest", Cell.show(rest));
+        (rest, c);
+      }
+    }
   | Some(M(l, w, r)) =>
     switch (side) {
     | L =>
@@ -61,21 +75,48 @@ module Cells = {
     // where c holds the meld {} " " {|} " " {}, the caret | will be pulled
     // left side of any grout inserted between the spaces, which is afaict always
     // what we want after any modification (except maybe forward delete)
-    let (l, cs) =
-      switch (cs) {
-      | [c, ...cs] =>
-        let (l, c) = split_cell_padding(~side=L, c);
-        (l, cons(c, cs));
-      | [] => (Cell.empty, cs)
-      };
-    let (cs, r) =
-      switch (Lists.Framed.ft(cs)) {
-      | Some((cs, c)) =>
-        let (r, c) = split_cell_padding(~side=R, c);
-        (List.rev(cons(c, cs)), r);
-      | None => (cs, Cell.empty)
-      };
-    (l, squash(cs), r);
+    switch (cs) {
+    | [c] when Cell.Space.is_space(c) =>
+      // P.log("Special split_padding case");
+      // P.show("r: ", Cell.show(r));
+      // P.show("c: ", Cell.show(c));
+
+      let (cs, r) =
+        switch (Lists.Framed.ft(cs)) {
+        | Some((cs, c)) =>
+          let (r, c) = split_cell_padding(~side=R, c);
+          (List.rev(cons(c, cs)), r);
+        | None => (cs, Cell.empty)
+        };
+      // P.show("cs: ", show(cs));
+      // P.show("r: ", Cell.show(r));
+      let (l, cs) =
+        switch (cs) {
+        | [c, ...cs] =>
+          let (l, c) = split_cell_padding(~side=L, c);
+          (l, cons(c, cs));
+        | [] => (Cell.empty, cs)
+        };
+      // P.show("l: ", Cell.show(l));
+      // P.show("final cs: ", show(cs));
+      (l, squash(cs), r);
+    | _ =>
+      let (l, cs) =
+        switch (cs) {
+        | [c, ...cs] =>
+          let (l, c) = split_cell_padding(~side=L, c);
+          (l, cons(c, cs));
+        | [] => (Cell.empty, cs)
+        };
+      let (cs, r) =
+        switch (Lists.Framed.ft(cs)) {
+        | Some((cs, c)) =>
+          let (r, c) = split_cell_padding(~side=R, c);
+          (List.rev(cons(c, cs)), r);
+        | None => (cs, Cell.empty)
+        };
+      (l, squash(cs), r);
+    };
   };
 
   // output Some(b) if bounded, where b indicates whether pre/post grout needed
@@ -112,12 +153,12 @@ let rec degrout = (c: Cell.t): Cells.t =>
   switch (Cell.get(c)) {
   //open the cell
   | Some(M(l, w, r)) when Option.is_some(Wald.is_grout(w)) =>
-    P.log("degrout hit some case");
+    // P.log("degrout hit some case");
     //pull the inner cells out ("base")
     let W((toks, cells)) = w;
-    P.show("l: ", Cell.show(l));
-    P.show("w: ", Wald.show(w));
-    P.show("r: ", Cell.show(r));
+    // P.show("l: ", Cell.show(l));
+    // P.sexp("w: ", Wald.sexp_of_t(w));
+    // P.show("r: ", Cell.show(r));
     List.iter(Effects.remove, toks);
     // we wish to maximally stabilize grout positioning, ie grout that is removed
     // in this pass, if reinserted, should be reinserted in the same position.
@@ -137,7 +178,9 @@ let rec degrout = (c: Cell.t): Cells.t =>
         P.show("degrout cells_l", Cell.show(l));
         let l = Cell.mark_degrouted(l, ~side=R);
         [l];
-      | _ => [l, ...cells]
+      | _ =>
+        let l = Cell.mark_degrouted(l, ~side=R);
+        [l, ...cells];
       };
     let cells_lr =
       switch (Lists.Framed.ft(cells_l)) {
@@ -149,7 +192,9 @@ let rec degrout = (c: Cell.t): Cells.t =>
         let r = Cell.mark_degrouted(~side=L, r);
         P.show("degrout cells_r", Cell.show(l));
         [r];
-      | _ => cells_l @ [r]
+      | _ =>
+        let r = Cell.mark_degrouted(r, ~side=L);
+        cells_l @ [r];
       };
     List.concat_map(degrout, cells_lr);
   | _ => [c]
@@ -188,10 +233,10 @@ let fill_default =
 let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
   let cs = Dir.pick(from, (List.rev, Fun.id), cs);
   // if (dbg^) {
-  // P.log("--- Grouter.fill_swing");
-  // P.show("from", Dir.show(from));
-  // P.show("sw", Walk.Swing.show(sw));
-  // P.show("cs", Cells.show(cs));
+  P.log("--- Grouter.fill_swing");
+  P.show("from", Dir.show(from));
+  P.show("sw", Walk.Swing.show(sw));
+  P.show("cs", Cells.show(cs));
   // };
   let (bot, top) = Walk.Swing.(bot(sw), top(sw));
   switch (bot) {
@@ -244,28 +289,29 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
     //NOTE: split padding is a possible candidate for newline bug fix
     switch (Cells.split_padding(cs)) {
     | (l, cs, r) when List.for_all(Cell.Space.is_space, cs) =>
-      if (dbg^) {
-        P.log("--- Grouter.fill_swing/Tile/all space");
-        P.show("l", Cell.show(l));
-        P.show("cs", Cells.show(cs));
-        P.show("r", Cell.show(r));
-      };
+      // if (dbg^) {
+      P.log("--- Grouter.fill_swing/Tile/all space");
+      P.show("l", Cell.show(l));
+      P.show("cs", Cells.show(cs));
+      P.show("r", Cell.show(r));
+      // };
       // prioritize getting any carets in cs over to the left for now.
       // todo: parametrize this based on parsing mode
       let l = List.hd(Cells.squash([l, ...cs]));
+      P.show("squashed l", Cell.show(l));
       // let r = List.hd(Cells.squash(cs @ [r]));
-      let r = Cell.pad(~l, fill_default(bot), ~r);
-      if (dbg^) {
-        P.show("padded", Cell.show(r));
-      };
-      r;
+      let ret = Cell.pad(~l, fill_default(bot), ~r);
+      // if (dbg^) {
+      P.show("padded", Cell.show(ret));
+      // };
+      ret;
     | (l, cs, r) =>
-      if (dbg^) {
-        P.log("--- Grouter.fill_swing/Tile/not all space");
-        P.show("l", Cell.show(l));
-        P.show("cs", Cells.show(cs));
-        P.show("r", Cell.show(r));
-      };
+      // if (dbg^) {
+      P.log("--- Grouter.fill_swing/Tile/not all space");
+      P.show("l", Cell.show(l));
+      P.show("cs", Cells.show(cs));
+      P.show("r", Cell.show(r));
+      // };
       //cells is list of children cells for target grout form
       //cons/scnoc here effectively add l/r as children of prefix/postfix grout
       let cells =
@@ -318,12 +364,12 @@ let fill_swing = (cs: Cells.t, sw: Walk.Swing.t, ~from: Dir.t) => {
 
 let fill_swings =
     (~repair, ~from, cells: list(Cell.t), swings: list(Walk.Swing.t)) => {
-  if (dbg^) {
-    P.log("--- Grouter.fill_swings");
-    P.show("from", Dir.show(from));
-    P.show("cells", Cells.show(Dir.pick(from, (List.rev, Fun.id), cells)));
-    // P.show("swings", Fmt.to_to_string(Fmt.list(Walk.Swing.pp), swings));
-  };
+  // if (dbg^) {
+  P.log("--- Grouter.fill_swings");
+  // P.show("from", Dir.show(from));
+  // P.show("cells", Cells.show(Dir.pick(from, (List.rev, Fun.id), cells)));
+  // P.show("swings", Fmt.to_to_string(Fmt.list(Walk.Swing.pp), swings));
+  // };
   cells
   |> Dir.pick(from, (List.rev, Fun.id))
   |> (repair ? List.concat_map(degrout) : Fun.id)
@@ -355,15 +401,14 @@ let fill = (~repair, ~from, cs, (swings, stances): Walk.t) => {
 //cs should be a singleton cell
 let pick = (~repair=false, ~from: Dir.t, cs: list(Cell.t), ws: list(Walk.t)) => {
   // if (dbg^) {
-  // P.log("--- Grouter.pick");
+  P.log("--- Grouter.pick");
   // P.show("from", Dir.show(from));
   // P.show("cs", Cells.show(cs));
   // P.log("ws");
   // ws |> List.iter(w => P.show("w", Walk.show(w)));
   // };
-  Oblig.Delta.minimize(
-    ~to_zero=!repair,
-    fill(~repair, ~from, cs),
-    ws,
-  );
+  let r =
+    Oblig.Delta.minimize(~to_zero=!repair, fill(~repair, ~from, cs), ws);
+  P.log("Grouter.pick done");
+  r;
 };
diff --git a/src/core/parser/Melder.re b/src/core/parser/Melder.re
@@ -23,14 +23,15 @@ let complete_wald = (~side: Dir.t, ~fill=Cell.empty, w: Wald.t): Terr.t => {
 };
 // onto confusing here when considered alone, same onto piped from push(~onto)
 let complete_terr = (~onto: Dir.t, ~fill=Cell.empty, terr: Terr.t): Cell.t => {
+  P.log("--- Melder.complete_terr");
+  P.show("onto", Dir.show(onto));
+  P.show("fill", Cell.show(fill));
+  P.show("terr", Terr.show(terr));
+
   let orient = Dir.pick(onto, (Meld.rev, Fun.id));
   let exited = Walker.exit(~from=onto, Node(Terr.face(terr).mtrl));
   let grouted = Grouter.pick(~repair=true, ~from=onto, [fill], exited);
   // if (debug^) {
-  // P.log("--- Melder.complete_terr");
-  // P.show("onto", Dir.show(onto));
-  // P.show("fill", Cell.show(fill));
-  // P.show("terr", Terr.show(terr));
   // };
   switch (grouted) {
   | Some(grouted) =>
diff --git a/src/core/structure/Cell.re b/src/core/structure/Cell.re
@@ -225,6 +225,35 @@ let get = (~distribute=true, c: t) =>
   (distribute ? distribute_marks : Fun.id)(c).meld;
 let put = (meld: Meld.t(_)) => aggregate_marks(mk(~meld, ()));
 
+let rec split_edge = (~side: Dir.t, c: t) =>
+  switch (get(c)) {
+  | None =>
+    // P.log("------ split_edge none  ------");
+    // P.show("c: ", show(c));
+    (c, {
+          ...c,
+          marks: {
+            ...c.marks,
+            cursor: None,
+          },
+        })
+  //NOTE: this is somehow the problem - the l & r are empty
+  | Some(M(l, w, r)) =>
+    // P.log("----- split_edge some ---- from: " ++ Dir.show(side));
+    // P.sexp("init c: ", sexp_of_t(c));
+    // P.show("r: ", show(r));
+    // P.show("w: ", Wald.show(Token.pp, pp, w));
+    // P.show("marks: ", Marks.show(c.marks));
+    // P.sexp("l: ", sexp_of_t(l));
+    let (d, b) = Dir.order(side, (l, r));
+    // P.show("recursive split_edge d:", show(d));
+    let (c, d) = split_edge(~side, d);
+    // P.show("post rec split_edge c:", show(c));
+    let (l, r) = Dir.order(side, (d, b));
+    let rest = put(M(l, w, r));
+    (c, rest);
+  };
+
 let caret = (car: Path.Caret.t) =>
   mk(~marks=Marks.mk(~cursor=Point(car), ()), ());
 
@@ -293,7 +322,9 @@ module Space = {
       cs
       |> Lists.split_while(~f=(c: t) => Path.Map.is_empty(c.marks.degrouted));
     switch (cs_d, cs_b) {
+    //we failed to find a degrouted mark
     | (_, []) => None
+    //immediately encounter degrout on the "d" side
     | ([], [b_hd, ...b_tl]) =>
       //ensuring no cursor duplication in cells with degrouted mark
       let b_hd_dup = {
@@ -303,21 +334,28 @@ module Space = {
           cursor: None,
         },
       };
+
+      //logic to handle the cursor jumping when coming from the left
+      let (b_hd, b_hd_dup) = Dir.order(d, (b_hd, b_hd_dup));
+
       let rest =
         Meld.of_chain(([b_hd_dup, ...b_tl], ts))
         |> Dir.pick(d, (Fun.id, Meld.rev))
         |> put;
       Some((b_hd, rest));
     | ([_, ..._], [b_hd, ...b_tl]) =>
       let (ts_d, ts_b) = Lists.split_n(ts, List.length(cs_d));
-      let cs_d = cs_d @ [b_hd];
       let b_hd_dup = {
         ...b_hd,
         marks: {
           ...b_hd.marks,
           cursor: None,
         },
       };
+      //logic to handle the cursor jumping when coming from the left
+      let (b_hd, b_hd_dup) = Dir.order(d, (b_hd, b_hd_dup));
+
+      let cs_d = cs_d @ [b_hd];
       let cs_b = [b_hd_dup, ...b_tl];
       let split =
         (cs_d, ts_d)
