fixed newline hole bug

Author: green726

src/core/editor/Modify.re

@@ -591,9 +591,9 @@ let apply_changes =
 
 let apply_remold = (changes, ctx) => {
   open Choice.Syntax;
-  // P.log("--- Modify.apply_remold");
-  // P.show("changes", Changes.show(changes));
-  // P.show("ctx", Ctx.show(ctx));
+  P.log("--- Modify.apply_remold");
+  P.show("changes", Changes.show(changes));
+  P.show("ctx", Ctx.show(ctx));
   let+ changed = apply_changes(changes, ctx);
   () => {
     open Options.Syntax;

src/core/parser/Grouter.re

@@ -29,6 +29,32 @@ let rec split_cell_padding = (~side: Dir.t, c: Cell.t) =>
     }
   };
 
+let rec extract_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)) =>
+    P.show("hit extract_cell_padding.space", Cell.show(c));
+    switch (Cell.Space.split_cursor(c)) {
+    | Some(s) =>
+      P.show(
+        "hit extract_cell_padding.split_cursor some fst: ",
+        Cell.show(fst(s)),
+      );
+      P.show("snd: ", Cell.show(snd(s)));
+      s;
+    | None => (c, Cell.empty)
+    };
+  | Some(M(l, w, r)) =>
+    switch (side) {
+    | L =>
+      let (p_l, l) = extract_cell_padding(~side=L, l);
+      Cell.(p_l, put(M(l, w, r)));
+    | R =>
+      let (p_r, r) = extract_cell_padding(r, ~side=R);
+      Cell.(p_r, put(M(l, w, r)));
+    }
+  };
+
 module Cells = {
   [@deriving (show({with_path: false}), sexp, yojson)]
   type t = list(Cell.t);
@@ -160,6 +186,26 @@ let rec degrout = (c: Cell.t): Cells.t =>
   | _ => [c]
   };
 
+let extract_newline = (~from: Dir.t, cs: Cells.t) => {
+  switch (cs) {
+  | [c] =>
+    switch (from) {
+    | L =>
+      let (pad, c) = extract_cell_padding(~side=R, c);
+      ([c], pad);
+    | R => (cs, Cell.empty)
+    }
+  | _ => (cs, Cell.empty)
+  };
+};
+
+let reinsert_newline = (~from: Dir.t, grouted: Grouted.t, nl: Cell.t) => {
+  switch (from) {
+  | L => Chain.map_hd(Tuples.map_snd(Cell.pad(~r=nl)), grouted)
+  | R => grouted
+  };
+};
+
 let fill_default =
   fun
   | Mtrl.Space(_) => Cell.dirty
@@ -266,16 +312,26 @@ let fill = (~repair, ~from, cs, (swings, stances): Walk.t) => {
 // obligation delta. the given cells are expected to be oriented the same way as the
 // given walks according to from.
 let pick = (~repair=false, ~from: Dir.t, cs: list(Cell.t), ws: list(Walk.t)) => {
+  open Options.Syntax;
   // if (dbg^) {
-  //   P.log("--- Grouter.pick");
-  //   P.show("from", Dir.show(from));
-  //   P.show("cs", Cells.show(cs));
+  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 (cs, nl) = extract_newline(~from, cs);
+
+  P.show("cs post newline extract", Cells.show(cs));
+  P.show("nl", Cell.show(nl));
+
+  let+ grouted =
+    Oblig.Delta.minimize(~to_zero=!repair, fill(~repair, ~from, cs), ws);
+
+  P.show("grouted no nl", Grouted.show(grouted));
+
+  let reinsert = reinsert_newline(~from, grouted, nl);
+  P.show("grouted with nl ", Grouted.show(reinsert));
+  reinsert;
 };

src/core/structure/Cell.re

@@ -296,6 +296,63 @@ module Space = {
     | _ => put(Meld.of_chain((cs, ts)))
     };
 
+  let split_cursor = (c: t) => {
+    open Options.Syntax;
+    assert(is_space(c));
+    //g = general get
+    //calling get on a space cell (spaces separated by empty cells with potential metadata ie degrout)
+    let* m = g(c);
+    //cd is now reversed to be from the right
+    let (cs, ts) = m |> Meld.rev |> Meld.to_chain;
+    cs |> List.iter(c => P.show("split_cursor_rev cs", show(c)));
+    ts |> List.iter(t => P.show("split_cursor_rev ts", Token.show(t)));
+    //traverses cells and searches for 1st cell with cursor mark
+    let (cs_r, cs_l) =
+      cs |> Lists.split_while(~f=(c: t) => Option.is_none(c.marks.cursor));
+
+    cs_r |> List.iter(c => P.show("split_cursor_cursor cs_r", show(c)));
+    cs_l |> List.iter(c => P.show("split_cursor_cursor cs_l", show(c)));
+
+    switch (cs_r, cs_l) {
+    //we failed to find a cursor mark
+    | (_, []) => None
+    //immediately encounter cursor on the "d" side
+    | ([], [l_hd, ...l_tl]) =>
+      //ensuring no cursor duplication in cells with cursor mark
+      let l_hd_dup = {
+        ...l_hd,
+        marks: {
+          ...l_hd.marks,
+          cursor: None,
+        },
+      };
+
+      P.show("l_hd_dup", show(l_hd_dup));
+
+      let rest = Meld.of_chain(([l_hd, ...l_tl], ts)) |> Meld.rev |> put;
+      Some((l_hd_dup, rest));
+    | ([_, ..._], [l_hd, ...l_tl]) =>
+      let (ts_r, ts_l) = Lists.split_n(ts, List.length(cs_r));
+      let l_hd_dup = {
+        ...l_hd,
+        marks: {
+          ...l_hd.marks,
+          cursor: None,
+        },
+      };
+
+      let cs_r = cs_r @ [l_hd_dup];
+      let cs_l = [l_hd, ...l_tl];
+      cs_r |> List.iter(c => P.show("cs_r", show(c)));
+      cs_l |> List.iter(c => P.show("cs_l", show(c)));
+      let split = (cs_r, ts_r) |> (c => Chain.rev(c)) |> Funs.uncurry(mk);
+      let rest = (cs_l, ts_l) |> (c => Chain.rev(c)) |> Funs.uncurry(mk);
+      ts_r |> List.iter(t => P.show("ts_r", Token.show(t)));
+      ts_l |> List.iter(t => P.show("ts_l", Token.show(t)));
+      Some((split, rest));
+    };
+  };
+
   // returns split-off cell first (regardless of side), rest of cell second
   // if i find a degrout mark within the space cell, split the cell into two at that point
   let split = (~side as d: Dir.t, c: t) => {

src/web/store/Store.re

@@ -25,7 +25,7 @@ let save_syntax_key: int => string =
 let save_syntax = (save_idx: int, z: Zipper.t) =>
   LocalStorage.set(save_syntax_key(save_idx), z |> serialize);
 
-let _tasks = [];
+// let tasks = [];
 let tasks =
   Data.[
     safe_div,