19210700935

Committed 09 Nov 2025 03:37PM UTC coverage: 81.818% (-4.7%) from 86.481%

Build # 19210700935

Build Type

push

github

Committed by

LuciaCastellucci

Commit Message

chore: merge branch 'feat/versioning' into dev

Coverage Stats

4 of 29 new or added lines in 2 files covered. (13.79%)

2 existing lines in 2 files now uncovered.

405 of 495 relevant lines covered (81.82%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/scala/model/ModelModule.scala

package model

import model.game.GameState

object ModelModule:

  trait Model:
    def state: GameState
    def updateState(updater: GameState => GameState): GameState
    def startTimer(): Unit
    def resetState(): GameState

    def addHint(hint: game.Hint): GameState =
      updateState(_.addHint(hint))

    def updateHistory(f: game.History => game.History): GameState =
      updateState(_.updateHistory(f))

    def addGraphToHistory(graph: game.CaseKnowledgeGraph): GameState =
      updateState(_.addGraphToHistory(graph))

    def undo(): Option[game.CaseKnowledgeGraph] =
      state.history.flatMap { history =>
        val (newHistory, previousGraph) = history.undo()
        previousGraph.map { graph =>
          updateState(_.withHistory(newHistory))
          graph
        }
      }

    def redo(): Option[game.CaseKnowledgeGraph] =
      state.history.flatMap { history =>
        val (newHistory, nextGraph) = history.redo()
        nextGraph.map { graph =>
          updateState(_.withHistory(newHistory))
          graph
        }
      }

    def saveSnapshot(): Unit =
      state.history.foreach { history =>
        state.timeMachine.foreach { tm =>
          tm.save(history)
        }
      }

    def restoreSnapshot(): Option[game.CaseKnowledgeGraph] =
      state.timeMachine.flatMap { tm =>
        tm.restore().map { restoredHistory =>
          updateState(_.withHistory(restoredHistory))
          tm.clear()
          restoredHistory.currentState.getOrElse(
            new game.CaseKnowledgeGraph()
          )
        }
      }

    def hasSnapshot: Boolean =
      state.timeMachine.exists(_.hasSnapshot)

    def clearSnapshot(): Unit =
      state.timeMachine.foreach(_.clear())

  trait Provider:
    def model: Model

  trait Component:

    class ModelImpl extends Model:

      @volatile private var currentState: GameState = GameState.empty()

      override def state: GameState = currentState

      override def updateState(updater: GameState => GameState): GameState =
        synchronized {
          currentState = updater(currentState)
          currentState
        }

      override def resetState(): GameState =
        synchronized {
          currentState = GameState.empty()
          currentState
        }

      override def startTimer(): Unit =
        synchronized {
          currentState.timer.foreach(_.start())
        }

  trait Interface extends Provider with Component:
    override lazy val model: Model = new ModelImpl()

1	package model
2
3	import model.game.GameState
4
5	object ModelModule:
6
7	trait Model:
8	def state: GameState
9	def updateState(updater: GameState => GameState): GameState
10	def startTimer(): Unit
11	def resetState(): GameState
12
13	def addHint(hint: game.Hint): GameState =	×
14	updateState(_.addHint(hint))	×
15
16	def updateHistory(f: game.History => game.History): GameState =	×
17	updateState(_.updateHistory(f))	×
18
19	def addGraphToHistory(graph: game.CaseKnowledgeGraph): GameState =	×
20	updateState(_.addGraphToHistory(graph))	×
21
NEW 22	def undo(): Option[game.CaseKnowledgeGraph] =	×
NEW 23	state.history.flatMap { history =>	×
NEW 24	val (newHistory, previousGraph) = history.undo()	×
NEW 25	previousGraph.map { graph =>	×
NEW 26	updateState(_.withHistory(newHistory))	×
27	graph
28	}
29	}
30
NEW 31	def redo(): Option[game.CaseKnowledgeGraph] =	×
NEW 32	state.history.flatMap { history =>	×
NEW 33	val (newHistory, nextGraph) = history.redo()	×
NEW 34	nextGraph.map { graph =>	×
NEW 35	updateState(_.withHistory(newHistory))	×
36	graph
37	}
38	}
39
NEW 40	def saveSnapshot(): Unit =	×
NEW 41	state.history.foreach { history =>	×
NEW 42	state.timeMachine.foreach { tm =>	×
NEW 43	tm.save(history)	×
44	}
45	}
46
NEW 47	def restoreSnapshot(): Option[game.CaseKnowledgeGraph] =	×
NEW 48	state.timeMachine.flatMap { tm =>	×
NEW 49	tm.restore().map { restoredHistory =>	×
NEW 50	updateState(_.withHistory(restoredHistory))	×
NEW 51	tm.clear()	×
NEW 52	restoredHistory.currentState.getOrElse(	×
NEW 53	new game.CaseKnowledgeGraph()	×
54	)
55	}
56	}
57
NEW 58	def hasSnapshot: Boolean =	×
NEW 59	state.timeMachine.exists(_.hasSnapshot)	×
60
NEW 61	def clearSnapshot(): Unit =	×
NEW 62	state.timeMachine.foreach(_.clear())	×
63
64	trait Provider:
65	def model: Model
66
67	trait Component:
68
69	class ModelImpl extends Model:
70
71	@volatile private var currentState: GameState = GameState.empty()	×
72
73	override def state: GameState = currentState	×
74
75	override def updateState(updater: GameState => GameState): GameState =	×
76	synchronized {	×
77	currentState = updater(currentState)	×
78	currentState
79	}
80
81	override def resetState(): GameState =	×
82	synchronized {	×
83	currentState = GameState.empty()	×
84	currentState
85	}
86
87	override def startTimer(): Unit =	×
88	synchronized {	×
89	currentState.timer.foreach(_.start())	×
90	}
91
92	trait Interface extends Provider with Component:
93	override lazy val model: Model = new ModelImpl()	×

LuciaCastellucci / PPS-24-whodunnit / 19210700935

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous