Added a ext-monocle module with a few extensions for Monocle

Fixes #38

Author: japgolly

README.md

@@ -51,6 +51,9 @@ libraryDependencies += "com.github.japgolly.scalajs-react" %%% "test" % "0.6.1"
 libraryDependencies += "com.github.japgolly.scalajs-react" %%% "ext-scalaz71" % "0.6.1" // or
 libraryDependencies += "com.github.japgolly.scalajs-react" %%% "ext-scalaz70" % "0.6.1"
 
+// Monocle support
+libraryDependencies += "com.github.japgolly.scalajs-react" %%% "ext-monocle" % "0.6.1"
+
 // Extra features
 libraryDependencies += "com.github.japgolly.scalajs-react" %%% "extra" % "0.6.1"
 ```
@@ -128,6 +131,9 @@ Also included are `runStateF` methods which use a `ChangeFilter` typeclass to co
 See [ScalazExamples](https://github.com/japgolly/scalajs-react/tree/master/example/src/main/scala/japgolly/scalajs/react/example/ScalazExamples.scala) for a taste.
 Take a look at the [ScalazReact module](https://github.com/japgolly/scalajs-react/tree/master/scalaz-7.1/src/main/scala/japgolly/scalajs/react/ScalazReact.scala) for the source.
 
+#### Monocle
+A module with a extensions for [Monocle](https://github.com/julien-truffaut/Monocle) also exists under `ext-monocle`.
+
 
 Testing
 =======

core/src/main/scala/japgolly/scalajs/react/package.scala

@@ -298,9 +298,9 @@ package object react {
       () => _c.state,
       (a: S, cb: OpCallback) => _c.setState(a, cb))
 
-    @inline def focusState[B](f: S => B)(g: (S, B) => S)(implicit C: CC) = new ComponentStateFocus[B](
+    @inline def focusState[T](f: S => T)(g: (S, T) => S)(implicit C: CC) = new ComponentStateFocus[T](
       () => f(_c.state),
-      (b: B, cb: OpCallback) => _c.setState(g(_c.state, b), cb))
+      (b: T, cb: OpCallback) => _c.setState(g(_c.state, b), cb))
   }
 
   final class ComponentStateFocus[B] private[react](

doc/CHANGELOG-0.7.md

@@ -7,6 +7,7 @@ https://gist.github.com/japgolly/c68482dbadb0077f550c
 #### Changes
 * Added a router! _(See the `extra` module)_.
 * Moved `.experiment` into a new module called `extra`.
+* Added a `ext-monocle` module with a few extensions for [Monocle](https://github.com/julien-truffaut/Monocle).
 * More supported React tags and attributes.
 * More ScalazReact extensions: `{state,setState,modState,modStateF}IO`.
 * Removed deprecated methods marked for removal in 0.7.0.

monocle/src/main/scala/japgolly/scalajs/react/MonocleReact.scala

@@ -0,0 +1,28 @@
+package japgolly.scalajs.react
+
+import monocle._
+import scalaz.Functor
+import japgolly.scalajs.react.ScalazReact._
+
+object MonocleReact {
+
+  @inline implicit final def toMonRExtCompStateAccessOps[C[_]: CompStateAccess, S](c: C[S]) = new MonRExt_CompStateAccessOps(c)
+  final class MonRExt_CompStateAccessOps[C[_], S](val _c: C[S]) extends AnyVal {
+    // CompStateAccess[C] should really be a class param but then we lose the AnyVal
+    type CC = CompStateAccess[C]
+
+    @inline def focusStateL[T](l: Lens[S, T])(implicit C: CC) = new ComponentStateFocus[T](
+      () => l get _c.state,
+      (t: T, cb: OpCallback) => _c.modState(l set t, cb))
+  }
+
+  @inline implicit final class MonRExt_ReactSTOps[M[_], S, A](val _r: ReactST[M,S,A]) extends AnyVal {
+
+    @inline def zoomL[T](l: Lens[T, S])(implicit M: Functor[M]): ReactST[M, T, A] =
+      ReactS.zoom[M, S, T, A](_r, l.get, (a, b) => l.set(b)(a))
+  }
+
+  // Seriously, Scala, get your shit together.
+  @inline final implicit def moarScalaHandHoldingMon[P,S](b: BackendScope[P,S]): MonRExt_CompStateAccessOps[ComponentScope_SS, S] = (b: ComponentScope_SS[S])
+  @inline final implicit def moarScalaHandHoldingMon[P,S,B](b: ComponentScopeU[P,S,B]): MonRExt_CompStateAccessOps[ComponentScope_SS, S] = (b: ComponentScope_SS[S])
+}

project/Build.scala

@@ -85,6 +85,9 @@ object ScalajsReact extends Build {
     (_: Project).settings(s: _*)
   }
 
+  def extModuleName(shortName: String): PE =
+    _.settings(name := s"ext-$shortName")
+
   // ==============================================================================================
   lazy val root = Project("root", file("."))
     .aggregate(core, test, scalaz70, scalaz71, extra, ghpages)
@@ -104,7 +107,7 @@ object ScalajsReact extends Build {
 
   lazy val test = project
     .configure(commonSettings, publicationSettings, utestSettings)
-    .dependsOn(core, scalaz71, extra)
+    .dependsOn(core, scalaz71, extra, monocle)
     .settings(
       name := "test",
       scalacOptions += "-language:reflectiveCalls")
@@ -113,16 +116,22 @@ object ScalajsReact extends Build {
   def scalazModule(name: String, version: String) = {
     val shortName = name.replaceAll("[^a-zA-Z0-9]+", "")
     Project(shortName, file(name))
-      .configure(commonSettings, publicationSettings)
+      .configure(commonSettings, publicationSettings, extModuleName(shortName))
       .dependsOn(core)
       .settings(
-        Keys.name := s"ext-$shortName",
         libraryDependencies += "com.github.japgolly.fork.scalaz" %%% "scalaz-effect" % version)
   }
 
   lazy val scalaz70 = scalazModule("scalaz-7.0", "7.0.6")
   lazy val scalaz71 = scalazModule("scalaz-7.1", "7.1.0-4")
 
+  // ==============================================================================================
+  lazy val monocle = project
+    .configure(commonSettings, publicationSettings, extModuleName("monocle"))
+    .dependsOn(core, scalaz71)
+    .settings(
+      libraryDependencies += "com.github.japgolly.fork.monocle" %%% "monocle-core" % "1.0.1")
+
   // ==============================================================================================
   lazy val extra = project
     .configure(commonSettings, publicationSettings)
@@ -132,7 +141,7 @@ object ScalajsReact extends Build {
 
   // ==============================================================================================
   lazy val ghpages = Project("gh-pages", file("gh-pages"))
-    .dependsOn(core, scalaz71, extra)
+    .dependsOn(core, scalaz71, extra, monocle)
     .configure(commonSettings, useReact(), preventPublication)
     .settings(
       emitSourceMaps := false,

test/src/test/scala/japgolly/scalajs/react/CoreTest.scala

@@ -331,5 +331,15 @@ object CoreTest extends TestSuite {
           .componentDidMount(scope => assert(scope.refs("test").get == null))
       }
     }
+
+    'inference {
+      import TestUtil.Inference._
+      def st_get: S => T = null
+      def st_set: (S, T) => S = null
+
+      "BackendScope ops"    - test[BackendScope[Unit, S]      ](_.focusState[T](st_get)(st_set)).expect[ComponentStateFocus[T]]
+      "ComponentScopeM ops" - test[ComponentScopeM[U, S, U]   ](_.focusState[T](st_get)(st_set)).expect[ComponentStateFocus[T]]
+      "ReactComponentM ops" - test[ReactComponentM[U, S, U, N]](_.focusState[T](st_get)(st_set)).expect[ComponentStateFocus[T]]
+    }
   }
 }

test/src/test/scala/japgolly/scalajs/react/MonocleTest.scala

@@ -0,0 +1,24 @@
+package japgolly.scalajs.react
+
+import monocle._
+import utest._
+import React._
+import ScalazReact._
+import MonocleReact._
+
+object MonocleTest extends TestSuite {
+
+  val tests = TestSuite {
+
+    'inference {
+      import TestUtil.Inference._
+      val lensST: Lens[S, T] = null
+      val lensTS: Lens[T, S] = null
+
+      "BackendScope ops"    - test[BackendScope[Unit, S]      ](_ focusStateL lensST).expect[ComponentStateFocus[T]]
+      "ComponentScopeM ops" - test[ComponentScopeM[U, S, U]   ](_ focusStateL lensST).expect[ComponentStateFocus[T]]
+      "ReactComponentM ops" - test[ReactComponentM[U, S, U, N]](_ focusStateL lensST).expect[ComponentStateFocus[T]]
+      "ReactS.zoomL"        - test[ReactST[M, S, A]           ](_ zoomL lensTS      ).expect[ReactST[M, T, A]]
+    }
+  }
+}

test/src/test/scala/japgolly/scalajs/react/ScalazTest.scala

@@ -2,7 +2,7 @@ package japgolly.scalajs.react
 
 import japgolly.scalajs.react.test.ReactTestUtils
 import utest._
-import scalaz.{~>, StateT, Monad}
+import scalaz.StateT
 import scalaz.effect.IO
 import ScalazReact._
 
@@ -12,29 +12,18 @@ import ScalazReact._
  */
 object ScalazTest extends TestSuite {
 
-  def test[A] = new {
-    def apply[B](f: A => B) = new {
-      def expect[C](implicit ev: B =:= C): Unit = ()
-    }
-  }
-
-  trait M[A]
-  implicit val mMonad = null.asInstanceOf[Monad[M] with (M ~> IO)]
-  trait S
-  trait A
-  trait B
-  val c = null.asInstanceOf[ComponentScopeM[Unit, S, Unit]]
-  type U = Unit
-  type N = TopNode
-
   val tests = TestSuite {
+
     'inference {
+      import TestUtil.Inference._
+
       "runState(s.liftS)"   - test[StateT[M,S,A]              ](s => c.runState(s.liftS) ).expect[IO[A]]
       "_runState(f.liftS)"  - test[B => StateT[M,S,A]         ](s => c._runState(s.liftS)).expect[B => IO[A]]
-      "BackendScope ops"    - test[BackendScope[Unit, S]      ](_.modStateIO(identity)   ).expect[IO[Unit]]
-      "ComponentScopeM ops" - test[ComponentScopeM[U, S, U]   ](_.modStateIO(identity)   ).expect[IO[Unit]]
-      "ReactComponentM ops" - test[ReactComponentM[U, S, U, N]](_.modStateIO(identity)   ).expect[IO[Unit]]
+      "BackendScope ops"    - test[BackendScope[Unit, S]      ](_ modStateIO identity    ).expect[IO[Unit]]
+      "ComponentScopeM ops" - test[ComponentScopeM[U, S, U]   ](_ modStateIO identity    ).expect[IO[Unit]]
+      "ReactComponentM ops" - test[ReactComponentM[U, S, U, N]](_ modStateIO identity    ).expect[IO[Unit]]
     }
+
     'runState {
       val c = ReactTestUtils.renderIntoDocument(CoreTest.SI())
       assert(c.state == 123)

test/src/test/scala/japgolly/scalajs/react/TestUtil.scala

@@ -83,4 +83,27 @@ object TestUtil {
 
   def assertTypeMismatch(e: CompileError): Unit =
     assertContains(e.msg, "type mismatch")
-}
+
+  // ===================================================================================================================
+  object Inference {
+    import scalaz.{Monad, ~>}
+    import scalaz.effect.IO
+
+    def test[A] = new {
+      def apply[B](f: A => B) = new {
+        def expect[C](implicit ev: B =:= C): Unit = ()
+      }
+    }
+
+    trait M[A]
+    trait S
+    trait T
+    trait A
+    trait B
+    val c = null.asInstanceOf[ComponentScopeM[Unit, S, Unit]]
+    type U = Unit
+    type N = TopNode
+
+    implicit val mMonad = null.asInstanceOf[Monad[M] with (M ~> IO)]
+  }
+}