saving / loading disable status of cells

src/evaluation/Run.jl

@@ -5,7 +5,8 @@ import .ExpressionExplorer: FunctionNameSignaturePair, is_joined_funcname, Using
 Base.push!(x::Set{Cell}) = x
 
 "Run given cells and all the cells that depend on them, based on the topology information before and after the changes."
-function run_reactive!(session::ServerSession, notebook::Notebook, old_topology::NotebookTopology, new_topology::NotebookTopology, roots::Vector{Cell}; deletion_hook::Function=WorkspaceManager.delete_vars, persist_js_state::Bool=false)::TopologicalOrder
+function run_reactive!(session::ServerSession, notebook::Notebook, old_topology::NotebookTopology, new_topology::NotebookTopology, roots::Vector{Cell}; 
+		deletion_hook::Function=WorkspaceManager.delete_vars, persist_js_state::Bool=false, indirectly_deactivated::Union{Nothing, Vector{Cell}}=nothing)::TopologicalOrder
 	# make sure that we're the only `run_reactive!` being executed - like a semaphor
 	take!(notebook.executetoken)
 
@@ -35,13 +36,8 @@ function run_reactive!(session::ServerSession, notebook::Notebook, old_topology:
 	new_order = topological_order(notebook, new_topology, union(roots, keys(old_order.errable)))
 	to_run_raw = setdiff(union(new_order.runnable, old_order.runnable), keys(new_order.errable))::Vector{Cell} # TODO: think if old error cell order matters
 
-	# find (indirectly) deactivated cells and update their status
-	deactivated = filter(c -> c.running_disabled, notebook.cells)
-	indirectly_deactivated = collect(topological_order(notebook, new_topology, deactivated))
-	for cell in indirectly_deactivated
-		cell.running = false
-		cell.queued = false
-		cell.depends_on_disabled_cells = true
+	if indirectly_deactivated === nothing
+		indirectly_deactivated = disable_dependent_cells!(notebook, new_topology)
 	end
 
     to_run = setdiff(to_run_raw, indirectly_deactivated)
@@ -108,6 +104,23 @@ function run_reactive!(session::ServerSession, notebook::Notebook, old_topology:
 	return new_order
 end
 
+"""
+find (indirectly) deactivated cells and update their status
+"""
+function disable_dependent_cells!(notebook:: Notebook, topology:: NotebookTopology):: Vector{Cell}
+	for cell in notebook.cells
+		cell.depends_on_disabled_cells = false
+	end
+	deactivated = filter(c -> c.running_disabled, notebook.cells)
+	indirectly_deactivated = collect(topological_order(notebook, topology, deactivated))
+	for cell in indirectly_deactivated
+		cell.running = false
+		cell.queued = false
+		cell.depends_on_disabled_cells = true
+	end
+	return indirectly_deactivated
+end
+
 run_reactive_async!(session::ServerSession, notebook::Notebook, to_run::Vector{Cell}; kwargs...) = run_reactive_async!(session, notebook, notebook.topology, notebook.topology, to_run; kwargs...)
 
 function run_reactive_async!(session::ServerSession, notebook::Notebook, old::NotebookTopology, new::NotebookTopology, to_run::Vector{Cell}; run_async::Bool=true, kwargs...)
@@ -182,6 +195,8 @@ function update_save_run!(session::ServerSession, notebook::Notebook, cells::Arr
 
 	update_dependency_cache!(notebook)
 
+	indirectly_deactivated = disable_dependent_cells!(notebook, new)
+
 	session.options.server.disable_writing_notebook_files || save_notebook(notebook)
 
 	# _assume `prerender_text == false` if you want to skip some details_
@@ -214,7 +229,7 @@ function update_save_run!(session::ServerSession, notebook::Notebook, cells::Arr
 		sync_nbpkg(session, notebook; save=save)
 		if !(isempty(to_run_online) && session.options.evaluation.lazy_workspace_creation) && will_run_code(notebook)
 			# not async because that would be double async
-			run_reactive_async!(session, notebook, old, new, to_run_online; run_async=false, kwargs...)
+			run_reactive_async!(session, notebook, old, new, to_run_online; run_async=false, indirectly_deactivated=indirectly_deactivated, kwargs...)
 		end
 	end
 end

src/notebook/Notebook.jl

@@ -84,11 +84,15 @@ end
 const _notebook_header = "### A Pluto.jl notebook ###"
 # We use a creative delimiter to avoid accidental use in code
 # so don't get inspired to suddenly use these in your code!
-const _cell_id_delimiter = "# ╔═╡ "
-const _order_delimiter = "# ╠═"
-const _order_delimiter_folded = "# ╟─"
+const _cell_id_delimiter =                     "# ╔═╡ "
+const _order_delimiter =                       "# ╠═"
+const _order_delimiter_folded =                "# ╟─"
 const _cell_suffix = "\n\n"
 
+const _running_disabled_prefix =               "#=╠═╡ disabled\n"
+const _running_disabled_suffix =             "\n  ╠═╡ disabled =#"
+const _depends_on_disabled_cells_prefix =      "#=╠═╡ depends on disabled cell(s)\n"
+const _depends_on_disabled_cells_suffix =    "\n  ╠═╡ depends on disabled cell(s) =#"
 const _ptoml_cell_id = UUID(1)
 const _mtoml_cell_id = UUID(2)
 
@@ -121,7 +125,21 @@ function save_notebook(io, notebook::Notebook)
     for c in cells_ordered
         println(io, _cell_id_delimiter, string(c.cell_id))
         # write the cell code and prevent collisions with the cell delimiter
-        print(io, replace(c.code, _cell_id_delimiter => "# "))
+
+        if c.running_disabled
+            print(io, _running_disabled_prefix)
+            print(io, replace(c.code, _cell_id_delimiter => "# "))
+            print(io, _running_disabled_suffix)
+        elseif c.depends_on_disabled_cells
+            # if a cell is both disabled directly and indirectly, the first has higher priority
+            print(io, _depends_on_disabled_cells_prefix)
+            print(io, replace(c.code, _cell_id_delimiter => "# "))
+            print(io, _depends_on_disabled_cells_suffix)
+        else
+            # cell is not disabled on startup
+            print(io, replace(c.code, _cell_id_delimiter => "# "))
+        end
+
         print(io, _cell_suffix)
     end
 
@@ -211,10 +229,21 @@ function load_notebook_nobackup(io, path)::Notebook
             code_raw = String(readuntil(io, _cell_id_delimiter))
             # change Windows line endings to Linux
             code_normalised = replace(code_raw, "\r\n" => "\n")
+
+            # get the information if a cell is disabled
+            running_disabled = startswith(code_normalised, _running_disabled_prefix)
+            depends_on_disabled_cells = startswith(code_normalised, _depends_on_disabled_cells_prefix)
+
+            # remove the disabled on startup comments for further processing in Julia
+            code_normalised = replace(replace(code_normalised, _running_disabled_prefix => ""), _running_disabled_suffix => "")
+            code_normalised = replace(replace(code_normalised, _depends_on_disabled_cells_prefix => ""), _depends_on_disabled_cells_suffix => "")
+
             # remove the cell suffix
             code = code_normalised[1:prevind(code_normalised, end, length(_cell_suffix))]
 
             read_cell = Cell(cell_id, code)
+            read_cell.running_disabled = running_disabled
+            read_cell.depends_on_disabled_cells = depends_on_disabled_cells || running_disabled
             collected_cells[cell_id] = read_cell
         end
     end