Ch12 canvas anchors and misc cleanup (#251)

* Note on no tests and no intro for next chapter

* Add anchors

* move LSystem code outside of let block where possible

* Remove outdated references to Async chapter

* Remove intented anchors in script too

* Check helper scripts in CI

Make sure anchor removal script always works and doesn't
break tests. Also check solution reset script.

* Build book before testing anchor removal

Author: milesfrain

.travis.yml

@@ -15,6 +15,15 @@ script:
   - travis_fold end "test"
   - ./mdbook build
   - cp CNAME book/
+  - travis_fold start "remove anchors"
+  - ./scripts/removeAnchors.sh
+  - travis_fold end "remove anchors"
+  - travis_fold start "test again"
+  - ./scripts/testAll.sh
+  - travis_fold end "test again"
+  - travis_fold start "reset solutions"
+  - ./scripts/resetSolutions.sh
+  - travis_fold end "reset solutions"
 before_deploy:
   openssl aes-256-cbc -K $encrypted_189e52c2c347_key -iv $encrypted_189e52c2c347_iv -in deploy_key.enc -out deploy_key -d
 deploy:

exercises/chapter12/src/Example/LSystem.purs

@@ -10,54 +10,84 @@ import Graphics.Canvas (strokePath, setStrokeStyle, lineTo, moveTo,
 import Math as Math
 import Partial.Unsafe (unsafePartial)
 
-lsystem :: forall a m s. Monad m =>
-                         Array a ->
-                         (a -> Array a) ->
-                         (s -> a -> m s) ->
-                         Int ->
-                         s -> m s
+-- ANCHOR: lsystem_anno
+lsystem :: forall a m s
+         . Monad m
+         => Array a
+         -> (a -> Array a)
+         -> (s -> a -> m s)
+         -> Int
+         -> s
+         -> m s
+-- ANCHOR_END: lsystem_anno
+-- ANCHOR: lsystem_impl
 lsystem init prod interpret n state = go init n
   where
+-- ANCHOR_END: lsystem_impl
+-- ANCHOR: lsystem_go_s_0
   go s 0 = foldM interpret state s
-  go s m = go (concatMap prod s) (m - 1)
+-- ANCHOR_END: lsystem_go_s_0
+-- ANCHOR: lsystem_go_s_i
+  go s i = go (concatMap prod s) (i - 1)
+-- ANCHOR_END: lsystem_go_s_i
 
+-- ANCHOR: letter
 data Letter = L | R | F
+-- ANCHOR_END: letter
 
+-- ANCHOR: sentence
 type Sentence = Array Letter
+-- ANCHOR_END: sentence
 
+-- ANCHOR: state
 type State =
   { x :: Number
   , y :: Number
   , theta :: Number
   }
+-- ANCHOR_END: state
+
+-- ANCHOR: initial
+initial :: Sentence
+initial = [F, R, R, F, R, R, F, R, R]
+-- ANCHOR_END: initial
+
+-- ANCHOR: productions
+productions :: Letter -> Sentence
+productions L = [L]
+productions R = [R]
+productions F = [F, L, F, R, R, F, L, F]
+-- ANCHOR_END: productions
+
+-- ANCHOR: initialState
+initialState :: State
+initialState = { x: 120.0, y: 200.0, theta: 0.0 }
+-- ANCHOR_END: initialState
 
 main :: Effect Unit
 main = void $ unsafePartial do
   Just canvas <- getCanvasElementById "canvas"
   ctx <- getContext2D canvas
 
   let
-    initial :: Sentence
-    initial = [F, R, R, F, R, R, F, R, R]
-
-    productions :: Letter -> Sentence
-    productions L = [L]
-    productions R = [R]
-    productions F = [F, L, F, R, R, F, L, F]
-
+    -- ANCHOR: interpret_anno
     interpret :: State -> Letter -> Effect State
+    -- ANCHOR_END: interpret_anno
+    -- ANCHOR: interpretLR
     interpret state L = pure $ state { theta = state.theta - Math.tau / 6.0 }
     interpret state R = pure $ state { theta = state.theta + Math.tau / 6.0 }
+    -- ANCHOR_END: interpretLR
+    -- ANCHOR: interpretF
     interpret state F = do
       let x = state.x + Math.cos state.theta * 1.5
           y = state.y + Math.sin state.theta * 1.5
       moveTo ctx state.x state.y
       lineTo ctx x y
       pure { x, y, theta: state.theta }
-
-    initialState :: State
-    initialState = { x: 120.0, y: 200.0, theta: 0.0 }
+    -- ANCHOR_END: interpretF
 
   setStrokeStyle ctx "#000"
 
+-- ANCHOR: strokePath
   strokePath ctx $ lsystem initial productions interpret 5 initialState
+-- ANCHOR_END: strokePath

exercises/chapter12/src/Example/Random.purs

@@ -17,14 +17,21 @@ main = void $ unsafePartial do
   Just canvas <- getCanvasElementById "canvas"
   ctx <- getContext2D canvas
 
+-- ANCHOR: style
   setFillStyle ctx "#F00"
   setStrokeStyle ctx "#000"
+-- ANCHOR_END: style
 
+-- ANCHOR: for
   for_ (1 .. 100) \_ -> do
+-- ANCHOR_END: for
+-- ANCHOR: random
     x <- random
     y <- random
     r <- random
+-- ANCHOR_END: random
 
+-- ANCHOR: path
     let path = arc ctx
          { x     : x * 600.0
          , y     : y * 600.0
@@ -35,3 +42,4 @@ main = void $ unsafePartial do
 
     fillPath ctx path
     strokePath ctx path
+-- ANCHOR_END: path

exercises/chapter12/src/Example/Rectangle.purs

@@ -8,16 +8,22 @@ import Graphics.Canvas (rect, fillPath, setFillStyle, getContext2D,
                         getCanvasElementById)
 import Partial.Unsafe (unsafePartial)
 
+-- ANCHOR: main
 main :: Effect Unit
 main = void $ unsafePartial do
   Just canvas <- getCanvasElementById "canvas"
   ctx <- getContext2D canvas
+-- ANCHOR_END: main
 
+-- ANCHOR: setFillStyle
   setFillStyle ctx "#00F"
+-- ANCHOR_END: setFillStyle
 
+-- ANCHOR: fillPath
   fillPath ctx $ rect ctx
     { x: 250.0
     , y: 250.0
     , width: 100.0
     , height: 100.0
     }
+-- ANCHOR_END: fillPath

exercises/chapter12/src/Example/Refs.purs

@@ -28,6 +28,7 @@ render ctx count = void do
 
   setFillStyle ctx "#0F0"
 
+-- ANCHOR: withContext
   withContext ctx do
     let scaleX = Math.sin (toNumber count * Math.tau / 8.0) + 1.5
     let scaleY = Math.sin (toNumber count * Math.tau / 12.0) + 1.5
@@ -43,18 +44,23 @@ render ctx count = void do
       , width: 200.0
       , height: 200.0
       }
+-- ANCHOR_END: withContext
 
 main :: Effect Unit
 main = void $ unsafePartial do
   Just canvas <- getCanvasElementById "canvas"
   ctx <- getContext2D canvas
 
+-- ANCHOR: clickCount
   clickCount <- Ref.new 0
+-- ANCHOR_END: clickCount
 
   render ctx 0
 
   node <- querySelector "#canvas"
   for_ node $ addEventListener "click" $ void do
     logShow "Mouse clicked!"
+-- ANCHOR: count
     count <- Ref.modify (\count -> count + 1) clickCount
+-- ANCHOR_END: count
     render ctx count

exercises/chapter12/src/Example/Shapes.purs

@@ -10,6 +10,7 @@ import Graphics.Canvas (closePath, lineTo, moveTo, fillPath,
 import Math as Math
 import Partial.Unsafe (unsafePartial)
 
+-- ANCHOR: translate
 translate
   :: forall r
    . Number
@@ -20,6 +21,7 @@ translate dx dy shape = shape
   { x = shape.x + dx
   , y = shape.y + dy
   }
+-- ANCHOR_END: translate
 
 main :: Effect Unit
 main = void $ unsafePartial do
@@ -45,10 +47,12 @@ main = void $ unsafePartial do
     , end: Math.tau * 2.0 / 3.0
     }
 
+-- ANCHOR: path
   setFillStyle ctx "#F00"
 
   fillPath ctx $ do
     moveTo ctx 300.0 260.0
     lineTo ctx 260.0 340.0
     lineTo ctx 340.0 340.0
     closePath ctx
+-- ANCHOR_END: path

scripts/removeAnchors.sh

@@ -7,5 +7,5 @@ ALL_PURS=$(find exercises \( ! -regex '.*/\..*' \) -type f -name '*.purs')
 
 for f in $ALL_PURS; do
   # Delete lines starting with an '-- ANCHOR' comment
-  perl -ni -e 'print if !/^-- ANCHOR/' $f
+  perl -ni -e 'print if !/^\s*-- ANCHOR/' $f
 done

text/chapter11.md

@@ -1022,4 +1022,3 @@ We have seen how monad transformers allow us to write safe code in an imperative
 
 Monad transformers are an excellent demonstration of the sort of expressive code that can be written by relying on advanced type system features such as higher-kinded polymorphism and multi-parameter type classes.
 
-In the next chapter, we will see how monad transformers can be used to give an elegant solution to a common complaint when working with asynchronous JavaScript code - the problem of _callback hell_.