Added onUpdate support / DirtyState.

Author: darkfrog26

shared/src/main/scala/reactify/AbstractState.scala

@@ -5,14 +5,15 @@ import reactify.instance.{RecursionMode, StateInstanceManager}
 class AbstractState[T](override val distinct: Boolean,
                        cache: Boolean,
                        recursion: RecursionMode,
-                       transactional: Boolean) extends State[T] {
-  protected val manager = new StateInstanceManager[T](this, cache, recursion, transactional)
+                       transactional: Boolean,
+                       onUpdate: Boolean) extends State[T] {
+  protected val manager = new StateInstanceManager[T](this, cache, recursion, transactional, onUpdate)
 
   override def observing: Set[Observable[_]] = manager.observables
 
   override protected def value(): T = manager.get
 
-  override def set(value: => T): Unit = {
+  override protected def set(value: => T): Unit = {
     manager.replaceInstance(() => value)
   }
 }

shared/src/main/scala/reactify/DirtyState.scala

@@ -1,24 +1,6 @@
 package reactify
 
-import java.util.concurrent.atomic.AtomicReference
-
-// TODO: apply in StateInstanceManager
 trait DirtyState[T] extends AbstractState[T] {
-  private lazy val dirty = new AtomicReference[Option[() => T]](None)
-
-  def isDirty: Boolean = dirty.get().nonEmpty
-
-  def update(): Boolean = dirty.getAndSet(None) match {
-    case Some(value) => {
-      manager.replaceInstance(value)
-      true
-    }
-    case None => false
-  }
-
-  override def set(value: => T): Unit = if (manager.isEmpty) {
-    super.set(value)
-  } else {
-    dirty.set(Some(() => value))
-  }
+  def isDirty: Boolean = manager.isDirty
+  def update(): Boolean = manager.update()
 }

shared/src/main/scala/reactify/StateChannel.scala

@@ -5,7 +5,6 @@ import java.util.concurrent.atomic.AtomicBoolean
 import reactify.bind._
 
 trait StateChannel[T] extends State[T] with Channel[T] {
-  override def set(value: => T): Unit
   override def static(value: T): Unit = super.static(value)
 
   def bind[V](that: StateChannel[V], setNow: BindSet = BindSet.LeftToRight)

shared/src/main/scala/reactify/Transaction.scala

@@ -21,6 +21,17 @@ object Transaction {
     f
   }
 
+  def withTransaction(f: => Unit, transaction: Transaction = new Transaction()): Transaction = {
+    val previous = threadLocal.get()
+    threadLocal.set(Some(transaction))
+    try {
+      f
+    } finally {
+      threadLocal.set(previous)
+    }
+    transaction
+  }
+
   def inTransaction: Boolean = threadLocal.get().nonEmpty
 
   def update[T](manager: StateInstanceManager[T], f: Option[() => T]): Unit = threadLocal.get().get.update(manager, f)

shared/src/main/scala/reactify/Val.scala

@@ -14,7 +14,8 @@ class Val[T](function: () => T,
              distinct: Boolean = true,
              cache: Boolean = true,
              recursion: RecursionMode = RecursionMode.RetainPreviousValue,
-             transactional: Boolean = true) extends AbstractState[T](distinct, cache, recursion, transactional) {
+             transactional: Boolean = true,
+             onUpdate: Boolean = false) extends AbstractState[T](distinct, cache, recursion, transactional, onUpdate) {
   set(function())
 
   override def toString: String = s"Val($get)"
@@ -38,4 +39,22 @@ object Val {
     }
     new Val[T](f, distinct, cache, recursion, transactional)
   }
+
+  /**
+    * Creates a new instance of `Var` mixing in `DirtyState`.
+    */
+  def dirty[T](value: => T,
+               static: Boolean = false,
+               distinct: Boolean = true,
+               cache: Boolean = true,
+               recursion: RecursionMode = RecursionMode.RetainPreviousValue,
+               transactional: Boolean = true): Val[T] with DirtyState[T] = {
+    val f = if (static) {
+      val v: T = value
+      () => v
+    } else {
+      () => value
+    }
+    new Val[T](f, distinct, cache, recursion, transactional, onUpdate = true) with DirtyState[T]
+  }
 }

shared/src/main/scala/reactify/Var.scala

@@ -13,8 +13,10 @@ class Var[T](function: () => T,
              distinct: Boolean = true,
              cache: Boolean = true,
              recursion: RecursionMode = RecursionMode.RetainPreviousValue,
-             transactional: Boolean = true
-            ) extends Val[T](function, distinct, cache, recursion, transactional) with StateChannel[T] {
+             transactional: Boolean = true,
+             onUpdate: Boolean = false
+            ) extends Val[T](function, distinct, cache, recursion, transactional, onUpdate) with StateChannel[T] {
+  override def set(value: => T): Unit = super.set(value)
   def asVal: Val[T] = this
 
   override def toString: String = s"Var($get)"
@@ -61,7 +63,7 @@ object Var {
     } else {
       () => value
     }
-    new Var[T](f, distinct, cache, recursion, transactional) with DirtyState[T]
+    new Var[T](f, distinct, cache, recursion, transactional, onUpdate = true) with DirtyState[T]
   }
 
   def bound[T](get: => T,

shared/src/main/scala/reactify/instance/StateInstanceManager.scala

@@ -5,10 +5,12 @@ import reactify.{Listener, Observable, State, Transaction}
 class StateInstanceManager[T](state: State[T],
                               cache: Boolean,
                               recursion: RecursionMode,
-                              transactional: Boolean) {
+                              transactional: Boolean,
+                              onUpdate: Boolean) {
   @volatile private var previousValue: T = _
   @volatile private var instance: StateInstance[T] = StateInstance.empty[T]
   @volatile private[reactify] var observables: Set[Observable[_]] = Set.empty
+  @volatile private var updateTransaction: Option[Transaction] = None
   private val threadLocal = new ThreadLocal[StateInstance[T]] {
     override def initialValue(): StateInstance[T] = StateInstance.uninitialized[T]
   }
@@ -33,9 +35,29 @@ class StateInstanceManager[T](state: State[T],
     }
   }
 
+  def isDirty: Boolean = updateTransaction.nonEmpty
+
+  def update(): Boolean = synchronized {
+    updateTransaction.exists { t =>
+      t.commit()
+      updateTransaction = None
+      true
+    }
+  }
+
   def updateInstance(force: Boolean = false): Unit = synchronized {
     if (!force && transactional && Transaction.inTransaction) {
       Transaction.update(this, None)
+    } else if (!force && onUpdate && !instance.isEmpty) {
+      val transaction = updateTransaction match {
+        case Some(t) => t
+        case None => {
+          val t = new Transaction()
+          updateTransaction = Some(t)
+          t
+        }
+      }
+      transaction.update(this, None)
     } else {
       // Reset cache
       instance.reset()
@@ -76,6 +98,16 @@ class StateInstanceManager[T](state: State[T],
   def replaceInstance(f: () => T, force: Boolean = false): Unit = synchronized {
     if (!force && transactional && Transaction.inTransaction) {
       Transaction.update(this, Some(f))
+    } else if (!force && onUpdate && !instance.isEmpty) {
+      val transaction = updateTransaction match {
+        case Some(t) => t
+        case None => {
+          val t = new Transaction()
+          updateTransaction = Some(t)
+          t
+        }
+      }
+      transaction.update(this, Some(f))
     } else {
       val previous = recursion match {
         case RecursionMode.Static => StateInstance.empty[T]

shared/src/test/scala/specs/BasicSpec.scala

@@ -486,6 +486,16 @@ class BasicSpec extends WordSpec with Matchers {
       v.update()
       v() should be("Two")
     }
+    "modify the dependant value but not apply it" in {
+      val v1 = Var[Int](1)
+      val v2 = Val.dirty[String](s"v1 is ${v1()}")
+      v2.update()
+      v1 := 2
+      v1() should be(2)
+      v2() should be("v1 is 1")
+      v2.update()
+      v2() should be("v1 is 2")
+    }
     "only fire events upon update" in {
       val v = Var.dirty[Int](0)
       var firedFor = ListBuffer.empty[Int]