Separate "logged"

Author: Negabinary

src/web/Main.re

@@ -19,21 +19,21 @@ let restart_caret_animation = () =>
 
 let apply =
     (
-      model: History.Model.t,
-      action: History.Update.t,
+      model: Logged.Model.t,
+      action: Logged.Update.t,
       ~schedule_action,
       ~schedule_autosave,
     )
-    : History.Model.t => {
+    : Logged.Model.t => {
   restart_caret_animation();
 
   /* This function is split into two phases, update and calculate.
      The intention is that eventually, the calculate phase will be
      done automatically by incremental calculation. */
   // ---------- UPDATE PHASE ----------
-  let updated: Updated.t(History.Model.t) =
+  let updated: Updated.t(Logged.Model.t) =
     try(
-      History.Update.update(
+      Logged.Update.update(
         ~import_log=Log.import,
         ~get_log_and=Log.get_and,
         ~schedule_action,
@@ -58,7 +58,7 @@ let apply =
   let model' =
     try(
       updated.model
-      |> History.Update.calculate(
+      |> Logged.Update.calculate(
            ~schedule_action,
            ~is_edited=updated.is_edit,
            ~dynamics=true,
@@ -98,8 +98,8 @@ let start = {
   let%sub save_scheduler = BonsaiUtil.Alarm.alarm;
   let%sub (app_model, app_inject) =
     Bonsai.state_machine1(
-      (module History.Model),
-      (module History.Update),
+      (module Logged.Model),
+      (module Logged.Update),
       ~apply_action=
         (~inject, ~schedule_event, input) => {
           let schedule_action = x => schedule_event(inject(x));
@@ -112,8 +112,8 @@ let start = {
           apply(~schedule_action, ~schedule_autosave);
         },
       ~default_model=
-        History.Model.init()
-        |> History.Update.calculate(
+        Logged.Model.init()
+        |> Logged.Update.calculate(
              ~schedule_action=_ => (),
              ~is_edited=true,
              ~dynamics=false,
@@ -220,7 +220,8 @@ let start = {
         let _ = Haz3lcore.ProbePerform.FocusEffect.execute();
         /* Update floating elements (backpack) to viewport coordinates */
         FloatingElement.update_all();
-        model.current.globals.settings.core.statics ? Animation.go() : ();
+        model.current.current.globals.settings.core.statics
+          ? Animation.go() : ();
       },
       (),
     );
@@ -231,7 +232,7 @@ let start = {
   let%arr app_model = app_model
   and app_inject = app_inject;
   try(
-    History.View.view(app_model, ~inject=app_inject, ~get_log_and=Log.get_and)
+    Logged.View.view(app_model, ~inject=app_inject, ~get_log_and=Log.get_and)
   ) {
   | exc =>
     print_endline(

src/web/app/History.re

@@ -9,8 +9,6 @@ module Model = {
     current: state,
     undo_stack: list(Updated.t(state)),
     redo_stack: list(Updated.t(state)),
-    future_log: list((float, Page.Update.t)),
-    replay_toggle: bool,
   };
 
   let equal = (===);
@@ -19,8 +17,6 @@ module Model = {
     current: Page.Store.load(),
     undo_stack: [],
     redo_stack: [],
-    future_log: [],
-    replay_toggle: false,
   };
 };
 
@@ -30,15 +26,6 @@ module Update = {
   [@deriving (show({with_path: false}), sexp, yojson)]
   type t = Page.Update.t;
 
-  // let sexp = Page.Update.sexp_of_t(action);
-  // For now, we don't ignore any actions; add here if needed
-  // check if str contains "(Select (Term (Id" (ignoring whitespace)
-  // let str = Sexplib.Sexp.to_string(sexp);
-  // StringUtil.match(StringUtil.regexp("Select\\s*\\(Term\\s*\\(Id"), str);
-  let ignore_if_action_fails_in_log_replay = (_action: t): bool => {
-    false;
-  };
-
   [@deriving (show({with_path: false}), sexp, yojson)]
   let update =
       (
@@ -55,13 +42,10 @@ module Update = {
       | [] =>
         print_endline("Cannot undo");
         model |> Updated.raise_invalid_action;
-      | [x, ...rest] =>
-        Log.Entry.save(Log.Entry.mk(action));
-        {
+      | [x, ...rest] => {
           ...x,
           model: {
             current: x.model,
-            future_log: model.future_log,
             undo_stack: rest,
             redo_stack: [
               {
@@ -70,22 +54,18 @@ module Update = {
               },
               ...model.redo_stack,
             ],
-            replay_toggle: model.replay_toggle,
           },
-        };
+        }
       }
     | Globals(Redo) =>
       switch (model.redo_stack) {
       | [] =>
         print_endline("Cannot redo");
         model |> Updated.raise_invalid_action;
-      | [x, ...rest] =>
-        Log.Entry.save(Log.Entry.mk(action));
-        {
+      | [x, ...rest] => {
           ...x,
           model: {
             current: x.model,
-            future_log: model.future_log,
             undo_stack: [
               {
                 ...x,
@@ -94,135 +74,8 @@ module Update = {
               ...model.undo_stack,
             ],
             redo_stack: rest,
-            replay_toggle: model.replay_toggle,
           },
-        };
-      }
-    | Globals(Log(a)) =>
-      switch (a) {
-      | InitImport(f) =>
-        JsUtil.read_file(f, data =>
-          schedule_action(Globals(Log(FinishImport(data))))
-        );
-        model |> Updated.return_quiet;
-      | FinishImport(None) =>
-        LogSidebar.log_error("Log import failed");
-        model |> Updated.return_quiet;
-      | FinishImport(Some(data)) =>
-        let of_data = (data: string): list((float, Page.Update.t)) =>
-          Export.import_just_log(data)
-          |> Sexplib.Sexp.of_string
-          |> Log.Entry.s_of_sexp_opt
-          |> List.filter_map(x => x);
-        let actions =
-          data
-          |> of_data
-          |> Log.flatten_imports(~of_data)
-          |> (
-            x => {
-              LogSidebar.log_info(
-                "Imported log entries: " ++ string_of_int(List.length(x)),
-              );
-              x;
-            }
-          );
-        {
-          ...model,
-          future_log: model.future_log @ actions,
-        }
-        |> Updated.return_quiet;
-      | NextLog =>
-        switch (model.future_log) {
-        | [] =>
-          LogSidebar.log_info("No next log action to perform");
-          model |> Updated.return_quiet;
-        | [(t, next), ...rest] =>
-          LogSidebar.log_action(
-            "Applying next log action",
-            Some(JsUtil.print_timestamp(t)),
-          );
-          // Keep full action expression in console for detailed debugging
-          print_endline("Full action: " ++ Page.Update.show(next));
-          try({
-            let updated =
-              Page.Update.update(
-                ~import_log,
-                ~get_log_and,
-                ~schedule_action,
-                next,
-                model.current,
-              );
-            {
-              ...updated,
-              model: {
-                current: updated.model,
-                undo_stack: [
-                  {
-                    ...updated,
-                    model: model.current,
-                  },
-                  ...model.undo_stack,
-                ],
-                redo_stack: model.redo_stack,
-                future_log: rest,
-                replay_toggle: model.replay_toggle,
-              },
-            };
-          }) {
-          | _ =>
-            LogSidebar.log_error("Failed to apply log action");
-            Model.{
-              ...model,
-              future_log:
-                ignore_if_action_fails_in_log_replay(next)
-                  ? rest : model.future_log,
-              replay_toggle:
-                ignore_if_action_fails_in_log_replay(next)
-                  ? model.replay_toggle : false,
-            }
-            |> Updated.return_quiet;
-          };
-        }
-      | SkipLog =>
-        LogSidebar.log_action("Skipping the next log entry", None);
-        switch (model.future_log) {
-        | [] =>
-          LogSidebar.log_info("No log entry to skip");
-          model |> return_quiet;
-        | [(_, _), ...rest] =>
-          {
-            ...model,
-            future_log: rest,
-          }
-          |> return_quiet
-        };
-      | SkipExercise =>
-        LogSidebar.log_action(
-          "Skipping to the next exercise in the log",
-          None,
-        );
-        let rec skip_to_next_exercise = (log: list((float, Page.Update.t))) =>
-          switch (log) {
-          | [] => []
-          | [(_, Editors(SwitchMode(_))), ..._] as rest => rest
-          | [(_, Editors(Exercises(SwitchExercise(_)))), ..._] as rest => rest
-          | [(_, _), ...rest] => skip_to_next_exercise(rest)
-          };
-        {
-          ...model,
-          future_log: skip_to_next_exercise(model.future_log),
-        }
-        |> return_quiet;
-      | ToggleReplay =>
-        Model.{
-          ...model,
-          replay_toggle: !model.replay_toggle,
         }
-        |> return_quiet
-      | ClearLog =>
-        Log.DB.clear_and(() => ());
-        LogSidebar.log_info("Log cleared");
-        model |> return_quiet;
       }
     | action =>
       let current =
@@ -233,13 +86,11 @@ module Update = {
           action,
           model.current,
         );
-      let _ = Log.update(action, current);
       if (Page.Update.can_undo(action)) {
         {
           ...current,
           model: {
             current: current.model,
-            future_log: model.future_log,
             undo_stack: [
               {
                 ...current,
@@ -248,7 +99,6 @@ module Update = {
               ...model.undo_stack,
             ],
             redo_stack: [],
-            replay_toggle: model.replay_toggle,
           },
         };
       } else {
@@ -258,8 +108,6 @@ module Update = {
             current: current.model,
             undo_stack: model.undo_stack,
             redo_stack: model.redo_stack,
-            future_log: model.future_log,
-            replay_toggle: model.replay_toggle,
           },
         };
       };
@@ -278,8 +126,6 @@ module Update = {
       |> Page.Update.calculate(~schedule_action, ~is_edited, ~dynamics),
     undo_stack: model.undo_stack,
     redo_stack: model.redo_stack,
-    future_log: model.future_log,
-    replay_toggle: model.replay_toggle,
   };
 };