on master help sign in
Merge branch 'master' into ts-preload-alljs
commit0a12cb3574eac83cb9cd712ec629b6c32c9d2bd2 authorTom Smalley <tfsmalley@gmail.com> dateTue 30 Oct 2018, 14:14 (8 years ago) parent12637ebb76ec1d
5 files changed+161−35
lib/backend/src/Obelisk/Backend.hs+30−16 lib/frontend/src/Obelisk/Frontend.hs+11−8 lib/route/src/Obelisk/Route/Frontend.hs+108−2 lib/run/src/Obelisk/Run.hs+7−6 lib/selftest/src/Obelisk/SelfTest.hs+5−3
lib/backend/src/Obelisk/Backend.hs+30−16
@@ -5,6 +5,7 @@
55{-# LANGUAGE LambdaCase #-}
66{-# LANGUAGE MultiParamTypeClasses #-}
77{-# LANGUAGE OverloadedStrings #-}
8+{-# LANGUAGE ScopedTypeVariables #-}
89{-# LANGUAGE TemplateHaskell #-}
910module Obelisk.Backend
1011 ( Backend (..)
@@ -16,6 +17,8 @@ module Obelisk.Backend
1617 , serveDefaultObeliskApp
1718 , prettifyOutput
1819 , runBackend
20+ , staticRenderContentType
21+ , mkRouteToUrl
1922 ) where
2023
2124import Prelude hiding (id, (.))
@@ -38,8 +41,8 @@ import Obelisk.ExecutableConfig.Inject (injectExecutableConfigs)
3841import Obelisk.Frontend
3942import Obelisk.Route
4043import Reflex.Dom
41−import Snap (MonadSnap, Snap, commandLineConfig, defaultConfig, getsRequest, httpServe, rqPathInfo,
42− rqQueryString, writeBS, writeText)
44+import Snap (MonadSnap, Snap, commandLineConfig, defaultConfig, getsRequest, httpServe, modifyResponse
45+ , rqPathInfo, rqQueryString, setContentType, writeBS, writeText)
4346import Snap.Internal.Http.Server.Config (Config (accessLog, errorLog), ConfigLog (ConfigIoLog))
4447import System.IO (BufferMode (..), hSetBuffering, stderr, stdout)
4548
@@ -56,8 +59,8 @@ data GhcjsApp route = GhcjsApp
5659
5760-- | Serve a frontend, which must be the same frontend that Obelisk has built and placed in the default location
5861--TODO: The frontend should be provided together with the asset paths so that this isn't so easily breakable; that will probably make this function obsolete
59−serveDefaultObeliskApp :: MonadSnap m => ([Text] -> m ()) -> Frontend (R appRoute) -> R (ObeliskRoute appRoute) -> m ()
60−serveDefaultObeliskApp serveStaticAsset frontend = serveObeliskApp serveStaticAsset frontendApp
62+serveDefaultObeliskApp :: MonadSnap m => (R appRoute -> Text) -> ([Text] -> m ()) -> Frontend (R appRoute) -> R (ObeliskRoute appRoute) -> m ()
63+serveDefaultObeliskApp urlEnc serveStaticAsset frontend = serveObeliskApp urlEnc serveStaticAsset frontendApp
6164 where frontendApp = GhcjsApp
6265 { _ghcjsApp_compiled = defaultFrontendGhcjsAssets
6366 , _ghcjsApp_value = frontend
@@ -108,12 +111,12 @@ getRouteWith e = do
108111 pageName <- getPageName
109112 return $ tryDecode e pageName
110113
111−serveObeliskApp :: MonadSnap m => ([Text] -> m ()) -> GhcjsApp (R appRoute) -> R (ObeliskRoute appRoute) -> m ()
112−serveObeliskApp serveStaticAsset frontendApp = \case
113− ObeliskRoute_App appRouteComponent :=> Identity appRouteRest -> serveGhcjsApp frontendApp $ GhcjsAppRoute_App appRouteComponent :/ appRouteRest
114+serveObeliskApp :: MonadSnap m => (R appRoute -> Text) -> ([Text] -> m ()) -> GhcjsApp (R appRoute) -> R (ObeliskRoute appRoute) -> m ()
115+serveObeliskApp urlEnc serveStaticAsset frontendApp = \case
116+ ObeliskRoute_App appRouteComponent :=> Identity appRouteRest -> serveGhcjsApp urlEnc frontendApp $ GhcjsAppRoute_App appRouteComponent :/ appRouteRest
114117 ObeliskRoute_Resource resComponent :=> Identity resRest -> case resComponent :=> Identity resRest of
115118 ResourceRoute_Static :=> Identity pathSegments -> serveStaticAsset pathSegments
116− ResourceRoute_Ghcjs :=> Identity pathSegments -> serveGhcjsApp frontendApp $ GhcjsAppRoute_Resource :/ pathSegments
119+ ResourceRoute_Ghcjs :=> Identity pathSegments -> serveGhcjsApp urlEnc frontendApp $ GhcjsAppRoute_Resource :/ pathSegments
117120 ResourceRoute_JSaddleWarp :=> Identity _ -> do
118121 let msg = "Error: Obelisk.Backend received jsaddle request"
119122 liftIO $ putStrLn $ T.unpack msg
@@ -132,11 +135,15 @@ data GhcjsAppRoute :: (* -> *) -> * -> * where
132135 GhcjsAppRoute_App :: appRouteComponent a -> GhcjsAppRoute appRouteComponent a
133136 GhcjsAppRoute_Resource :: GhcjsAppRoute appRouteComponent [Text]
134137
138+staticRenderContentType :: ByteString
139+staticRenderContentType = "text/html; charset=utf-8"
140+
135141--TODO: Don't assume we're being served at "/"
136−serveGhcjsApp :: MonadSnap m => GhcjsApp (R appRouteComponent) -> R (GhcjsAppRoute appRouteComponent) -> m ()
137−serveGhcjsApp app = \case
138− GhcjsAppRoute_App appRouteComponent :=> Identity appRouteRest ->
139− writeBS <=< liftIO $ renderGhcjsFrontend (appRouteComponent :/ appRouteRest) $ _ghcjsApp_value app
142+serveGhcjsApp :: MonadSnap m => (R appRouteComponent -> Text) -> GhcjsApp (R appRouteComponent) -> R (GhcjsAppRoute appRouteComponent) -> m ()
143+serveGhcjsApp urlEnc app = \case
144+ GhcjsAppRoute_App appRouteComponent :=> Identity appRouteRest -> do
145+ modifyResponse $ setContentType staticRenderContentType
146+ writeBS <=< liftIO $ renderGhcjsFrontend urlEnc (appRouteComponent :/ appRouteRest) $ _ghcjsApp_value app
140147 GhcjsAppRoute_Resource :=> Identity pathSegments -> serveStaticAssets (_ghcjsApp_compiled app) pathSegments
141148
142149runBackend :: Backend fullRoute frontendRoute -> Frontend (R frontendRoute) -> IO ()
@@ -147,13 +154,20 @@ runBackend backend frontend = case checkEncoder $ _backend_routeEncoder backend
147154 getRouteWith validFullEncoder >>= \case
148155 Identity r -> case r of
149156 InL backendRoute :=> Identity a -> serveRoute $ backendRoute :/ a
150− InR obeliskRoute :=> Identity a -> serveDefaultObeliskApp (serveStaticAssets defaultStaticAssets) frontend $ obeliskRoute :/ a
157+ InR obeliskRoute :=> Identity a ->
158+ serveDefaultObeliskApp (mkRouteToUrl validFullEncoder) (serveStaticAssets defaultStaticAssets) frontend $ obeliskRoute :/ a
159+
160+mkRouteToUrl :: Encoder Identity parse (R (Sum f (ObeliskRoute r))) PageName -> R r -> Text
161+mkRouteToUrl validFullEncoder =
162+ let pageNameEncoder' :: Encoder Identity (Either Text) PageName PathQuery = pageNameEncoder
163+ in \(k :/ v) -> T.pack . uncurry (<>) . encode pageNameEncoder' . encode validFullEncoder $ (InR $ ObeliskRoute_App k) :/ v
164+
151165
152−renderGhcjsFrontend :: route -> Frontend route -> IO ByteString
153−renderGhcjsFrontend route f = do
166+renderGhcjsFrontend :: MonadIO m => (route -> Text) -> route -> Frontend route -> m ByteString
167+renderGhcjsFrontend urlEnc route f = do
154168 let baseTag = elAttr "base" ("href" =: "/") blank --TODO: Figure out the base URL from the routes
155169 ghcjsPreload = elAttr "link" ("rel" =: "preload" <> "as" =: "script" <> "href" =: "ghcjs/all.js") blank
156170 ghcjsScript = elAttr "script" ("language" =: "javascript" <> "src" =: "ghcjs/all.js" <> "defer" =: "defer") blank
157− renderFrontendHtml route
171+ liftIO $ renderFrontendHtml urlEnc route
158172 (_frontend_head f >> injectExecutableConfigs >> baseTag >> ghcjsPreload)
159173 (_frontend_body f >> ghcjsScript)
lib/frontend/src/Obelisk/Frontend.hs+11−8
@@ -32,6 +32,7 @@ import Data.Dependent.Sum (DSum (..))
3232import Data.Functor.Sum
3333import Data.IORef
3434import Data.Monoid ((<>))
35+import Data.Text (Text)
3536import GHCJS.DOM hiding (bracket, catch)
3637import GHCJS.DOM.Document
3738import GHCJS.DOM.Node
@@ -64,6 +65,7 @@ type ObeliskWidget t x route m =
6465 , PrimMonad m
6566 , Prerender x m
6667 , SetRoute t route m
68+ , RouteToUrl route m
6769 )
6870
6971data Frontend route = Frontend
@@ -143,22 +145,23 @@ runFrontend validFullEncoder frontend = do
143145 , MonadFix m
144146 , MonadFix (Performable m)
145147 )
146− => RoutedT t (R route) (SetRouteT t (R route) m) a
148+ => RoutedT t (R route) (SetRouteT t (R route) (RouteToUrlT (R route) m)) a
147149 -> m a
148150 runMyRouteViewT = runRouteViewT ve
149151 runWithHeadAndBody $ \appendHead appendBody -> runMyRouteViewT $ do
150− mapRoutedT (mapSetRouteT appendHead) $ _frontend_head frontend
151− mapRoutedT (mapSetRouteT appendBody) $ _frontend_body frontend
152+ mapRoutedT (mapSetRouteT (mapRouteToUrlT appendHead)) $ _frontend_head frontend
153+ mapRoutedT (mapSetRouteT (mapRouteToUrlT appendBody)) $ _frontend_body frontend
152154
153155renderFrontendHtml
154156 :: (t ~ DomTimeline)
155− => r
156− -> RoutedT t r (SetRouteT t r' (PostBuildT DomTimeline (StaticDomBuilderT DomTimeline (PerformEventT DomTimeline DomHost)))) ()
157− -> RoutedT t r (SetRouteT t r' (PostBuildT DomTimeline (StaticDomBuilderT DomTimeline (PerformEventT DomTimeline DomHost)))) ()
157+ => (r' -> Text)
158+ -> r
159+ -> RoutedT t r (SetRouteT t r' (RouteToUrlT r' (PostBuildT DomTimeline (StaticDomBuilderT DomTimeline (PerformEventT DomTimeline DomHost))))) ()
160+ -> RoutedT t r (SetRouteT t r' (RouteToUrlT r' (PostBuildT DomTimeline (StaticDomBuilderT DomTimeline (PerformEventT DomTimeline DomHost))))) ()
158161 -> IO ByteString
159−renderFrontendHtml route headWidget bodyWidget = do
162+renderFrontendHtml urlEnc route headWidget bodyWidget = do
160163 --TODO: We should probably have a "NullEventWriterT" or a frozen reflex timeline
161− html <- fmap snd $ renderStatic $ fmap fst $ runSetRouteT $ flip runRoutedT (pure route) $
164+ html <- fmap snd $ renderStatic $ fmap fst $ flip runRouteToUrlT urlEnc $ runSetRouteT $ flip runRoutedT (pure route) $
162165 el "html" $ do
163166 el "head" headWidget
164167 el "body" bodyWidget
lib/route/src/Obelisk/Route/Frontend.hs+108−2
@@ -41,6 +41,11 @@ module Obelisk.Route.Frontend
4141 , SetRoute(..)
4242 , runSetRouteT
4343 , mapSetRouteT
44+ , RouteToUrl(..)
45+ , RouteToUrlT(..)
46+ , runRouteToUrlT
47+ , mapRouteToUrlT
48+ , routeLink
4449 ) where
4550
4651import Prelude hiding ((.), id)
@@ -61,6 +66,8 @@ import Data.Constraint (Dict (..))
6166import Data.Dependent.Sum (DSum (..))
6267import Data.GADT.Compare
6368import Data.Monoid
69+import Data.Proxy
70+import Data.Text (Text)
6471import qualified Data.Text as T
6572import Data.Functor.Compose
6673import Reflex.Class
@@ -290,6 +297,85 @@ instance (Monad m, MonadQuery t vs m) => MonadQuery t vs (SetRouteT t r m) where
290297 askQueryResult = lift askQueryResult
291298 queryIncremental = lift . queryIncremental
292299
300+class RouteToUrl r m | m -> r where
301+ askRouteToUrl :: m (r -> Text)
302+
303+newtype RouteToUrlT r m a = RouteToUrlT { unRouteToUrlT :: ReaderT (r -> Text) m a }
304+ deriving (Functor, Applicative, Monad, MonadFix, MonadTrans, NotReady t, MonadHold t, MonadSample t, PostBuild t, TriggerEvent t, MonadIO, MonadReflexCreateTrigger t, HasDocument)
305+
306+runRouteToUrlT
307+ :: RouteToUrlT r m a
308+ -> (r -> Text)
309+ -> m a
310+runRouteToUrlT a = runReaderT (unRouteToUrlT a)
311+
312+mapRouteToUrlT :: (forall x. m x -> n x) -> RouteToUrlT r m a -> RouteToUrlT r n a
313+mapRouteToUrlT f (RouteToUrlT m) = RouteToUrlT $ mapReaderT f m
314+
315+instance Monad m => RouteToUrl r (RouteToUrlT r m) where
316+ askRouteToUrl = RouteToUrlT ask
317+
318+instance (Monad m, RouteToUrl r m) => RouteToUrl r (SetRouteT t r' m) where
319+ askRouteToUrl = lift askRouteToUrl
320+
321+instance (Monad m, RouteToUrl r m) => RouteToUrl r (RoutedT t r' m) where
322+ askRouteToUrl = lift askRouteToUrl
323+
324+instance HasJSContext m => HasJSContext (RouteToUrlT r m) where
325+ type JSContextPhantom (RouteToUrlT r m) = JSContextPhantom m
326+ askJSContext = lift askJSContext
327+
328+instance Prerender js m => Prerender js (RouteToUrlT r m) where
329+ prerenderClientDict = fmap (\Dict -> Dict) (prerenderClientDict :: Maybe (Dict (PrerenderClientConstraint js m)))
330+
331+instance Requester t m => Requester t (RouteToUrlT r m) where
332+ type Request (RouteToUrlT r m) = Request m
333+ type Response (RouteToUrlT r m) = Response m
334+ requesting = RouteToUrlT . requesting
335+ requesting_ = RouteToUrlT . requesting_
336+
337+#ifndef ghcjs_HOST_OS
338+deriving instance MonadJSM m => MonadJSM (RouteToUrlT r m)
339+#endif
340+
341+instance PerformEvent t m => PerformEvent t (RouteToUrlT r m) where
342+ type Performable (RouteToUrlT r m) = Performable m
343+ performEvent = lift . performEvent
344+ performEvent_ = lift . performEvent_
345+
346+instance MonadRef m => MonadRef (RouteToUrlT r m) where
347+ type Ref (RouteToUrlT r m) = Ref m
348+ newRef = lift . newRef
349+ readRef = lift . readRef
350+ writeRef r = lift . writeRef r
351+
352+instance HasJS x m => HasJS x (RouteToUrlT r m) where
353+ type JSX (RouteToUrlT r m) = JSX m
354+ liftJS = lift . liftJS
355+
356+instance MonadTransControl (RouteToUrlT r) where
357+ type StT (RouteToUrlT r) a = StT (ReaderT (r -> Text)) a
358+ liftWith = defaultLiftWith RouteToUrlT unRouteToUrlT
359+ restoreT = defaultRestoreT RouteToUrlT
360+
361+instance PrimMonad m => PrimMonad (RouteToUrlT r m ) where
362+ type PrimState (RouteToUrlT r m) = PrimState m
363+ primitive = lift . primitive
364+
365+instance DomBuilder t m => DomBuilder t (RouteToUrlT r m) where
366+ type DomBuilderSpace (RouteToUrlT r m) = DomBuilderSpace m
367+
368+instance Adjustable t m => Adjustable t (RouteToUrlT r m) where
369+ runWithReplace a0 a' = RouteToUrlT $ runWithReplace (coerce a0) $ coerceEvent a'
370+ traverseIntMapWithKeyWithAdjust f a0 a' = RouteToUrlT $ traverseIntMapWithKeyWithAdjust (coerce f) (coerce a0) $ coerce a'
371+ traverseDMapWithKeyWithAdjust f a0 a' = RouteToUrlT $ traverseDMapWithKeyWithAdjust (\k v -> coerce $ f k v) (coerce a0) $ coerce a'
372+ traverseDMapWithKeyWithAdjustWithMove f a0 a' = RouteToUrlT $ traverseDMapWithKeyWithAdjustWithMove (\k v -> coerce $ f k v) (coerce a0) $ coerce a'
373+
374+instance (Monad m, MonadQuery t vs m) => MonadQuery t vs (RouteToUrlT r m) where
375+ tellQueryIncremental = lift . tellQueryIncremental
376+ askQueryResult = lift askQueryResult
377+ queryIncremental = lift . queryIncremental
378+
293379runRouteViewT
294380 :: forall t m r a.
295381 ( TriggerEvent t m
@@ -300,7 +386,7 @@ runRouteViewT
300386 , MonadFix m
301387 )
302388 => (Encoder Identity Identity r PageName)
303− -> RoutedT t r (SetRouteT t r m) a
389+ -> RoutedT t r (SetRouteT t r (RouteToUrlT r m)) a
304390 -> m a
305391runRouteViewT routeEncoder a = do
306392 rec historyState <- manageHistory $ HistoryCommand_PushState <$> setState
@@ -313,7 +399,7 @@ runRouteViewT routeEncoder a = do
313399 where
314400 errorLeft (Left e) = error (T.unpack e)
315401 errorLeft (Right x) = x
316− (result, changeState) <- runSetRouteT $ runRoutedT a route
402+ (result, changeState) <- runRouteToUrlT (runSetRouteT $ runRoutedT a route) $ (\(p, q) -> T.pack $ p <> q) . encode theEncoder
317403 let f (currentHistoryState, oldRoute) change =
318404 let newRoute = appEndo change oldRoute
319405 (newPath, newQuery) = encode theEncoder newRoute
@@ -337,6 +423,26 @@ runRouteViewT routeEncoder a = do
337423 setState = attachWith f ((,) <$> current historyState <*> current route) changeState
338424 return result
339425
426+-- | A link widget that, when clicked, sets the route to the provided route. In non-javascript
427+-- contexts, this widget falls back to using @href@s to control navigation
428+routeLink
429+ :: forall t m a route.
430+ ( DomBuilder t m
431+ , RouteToUrl (R route) m
432+ , SetRoute t (R route) m
433+ )
434+ => R route -- ^ Target route
435+ -> m a -- ^ Child widget
436+ -> m a
437+routeLink r w = do
438+ enc <- askRouteToUrl
439+ let cfg = (def :: ElementConfig EventResult t (DomBuilderSpace m))
440+ & elementConfig_eventSpec %~ addEventSpecFlags (Proxy :: Proxy (DomBuilderSpace m)) Click (\_ -> preventDefault)
441+ & elementConfig_initialAttributes .~ "href" =: enc r
442+ (e, a) <- element "a" cfg w
443+ setRoute $ r <$ domEvent Click e
444+ return a
445+
340446-- On ios due to sandboxing when loading the page from a file adapt the
341447-- path to be based on the hash.
342448
lib/run/src/Obelisk/Run.hs+7−6
@@ -82,7 +82,8 @@ run port serveStaticAsset backend frontend = do
8282 getRouteWith validFullEncoder >>= \case
8383 Identity r -> case r of
8484 InL backendRoute :=> Identity a -> serveRoute $ backendRoute :/ a
85− InR obeliskRoute :=> Identity a -> serveDefaultObeliskApp serveStaticAsset frontend $ obeliskRoute :/ a
85+ InR obeliskRoute :=> Identity a ->
86+ serveDefaultObeliskApp (mkRouteToUrl validFullEncoder) serveStaticAsset frontend $ obeliskRoute :/ a
8687 let conf = defRunConfig { _runConfig_redirectPort = port }
8788 runWidget conf frontend validFullEncoder `finally` killThread backendTid
8889
@@ -142,15 +143,15 @@ obeliskApp opts frontend validFullEncoder uri backend = do
142143 { W.pathInfo = fst $ encode jsaddleWarpRouteValidEncoder jsaddleRoute
143144 }
144145 InR (ObeliskRoute_App appRouteComponent) :=> Identity appRouteRest -> do
145− html <- renderJsaddleFrontend (appRouteComponent :/ appRouteRest) frontend
146− sendResponse $ W.responseLBS H.status200 [("Content-Type", "text/html")] $ BSLC.fromStrict html
146+ html <- renderJsaddleFrontend (mkRouteToUrl validFullEncoder) (appRouteComponent :/ appRouteRest) frontend
147+ sendResponse $ W.responseLBS H.status200 [("Content-Type", staticRenderContentType)] $ BSLC.fromStrict html
147148 _ -> backend req sendResponse
148149
149−renderJsaddleFrontend :: route -> Frontend route -> IO ByteString
150−renderJsaddleFrontend r f =
150+renderJsaddleFrontend :: (route -> Text) -> route -> Frontend route -> IO ByteString
151+renderJsaddleFrontend urlEnc r f =
151152 let jsaddleScript = elAttr "script" ("src" =: "/jsaddle/jsaddle.js") blank
152153 jsaddlePreload = elAttr "link" ("rel" =: "preload" <> "as" =: "script" <> "href" =: "/jsaddle/jsaddle.js") blank
153− in renderFrontendHtml r (_frontend_head f >> injectExecutableConfigs >> jsaddlePreload) (_frontend_body f >> jsaddleScript)
154+ in renderFrontendHtml urlEnc r (_frontend_head f >> injectExecutableConfigs >> jsaddlePreload) (_frontend_body f >> jsaddleScript)
154155
155156-- | like 'bindPortTCP' but reconnects on exception
156157bindPortTCPRetry :: Settings
lib/selftest/src/Obelisk/SelfTest.hs+5−3
@@ -86,7 +86,9 @@ main = do
8686 let shelly_ = void . shellyOb verbosity
8787
8888 inTmp :: (Shelly.FilePath -> Sh a) -> IO ()
89− inTmp f = shelly_ . withSystemTempDirectory "test" $ (chdir <*> f) . fromString
89+ inTmp f = withTmp (chdir <*> f)
90+
91+ withTmp f = shelly_ . withSystemTempDirectory "test" $ f . fromString
9092
9193 inTmpObInit f = inTmp $ \dir -> do
9294 run_ "cp" ["-a", fromString $ initCache <> "/.", toTextIgnore dir]
@@ -181,12 +183,12 @@ main = do
181183 assertRevEQ eu eupu
182184 assertRevNE e eu
183185
184− it "unpacks the correct branch" $ inTmp $ \dir -> do
186+ it "unpacks the correct branch" $ withTmp $ \dir -> do
185187 let branch = "master"
186188 run_ "git" ["clone", "https://github.com/reflex-frp/reflex.git", toTextIgnore dir, "--branch", branch]
187189 run_ "ob" ["thunk", "pack", toTextIgnore dir]
188190 run_ "ob" ["thunk", "unpack", toTextIgnore dir]
189− branch' <- run "git" ["rev-parse", "--abbrev-ref", "HEAD"]
191+ branch' <- chdir dir $ run "git" ["rev-parse", "--abbrev-ref", "HEAD"]
190192 liftIO $ assertEqual "" branch (T.strip branch')
191193
192194 it "can pack and unpack plain git repos" $ do