diff --git a/project_template/barebones/foo.cabal b/project_template/barebones/foo.cabal --- a/project_template/barebones/foo.cabal +++ b/project_template/barebones/foo.cabal @@ -19,8 +19,8 @@ bytestring >= 0.9.1 && < 0.10, MonadCatchIO-transformers >= 0.2.1 && < 0.3, mtl >= 2 && < 3, - snap-core == 0.6.*, - snap-server == 0.6.* + snap-core == 0.7.*, + snap-server == 0.7.* if impl(ghc >= 6.12.0) ghc-options: -threaded -Wall -fwarn-tabs -funbox-strict-fields -O2 diff --git a/project_template/default/foo.cabal b/project_template/default/foo.cabal --- a/project_template/default/foo.cabal +++ b/project_template/default/foo.cabal @@ -23,14 +23,14 @@ bytestring >= 0.9.1 && < 0.10, data-lens >= 2.0.1 && < 2.1, data-lens-template >= 2.1 && < 2.2, - heist >= 0.6 && < 0.7, + heist >= 0.7 && < 0.8, MonadCatchIO-transformers >= 0.2.1 && < 0.3, mtl >= 2 && < 3, - snap == 0.6.*, - snap-core == 0.6.*, - snap-server == 0.6.*, + snap == 0.7.*, + snap-core == 0.7.*, + snap-server == 0.7.*, text >= 0.11 && < 0.12, - time >= 1.1 && < 1.4, + time >= 1.1 && < 1.5, xmlhtml == 0.1.* if flag(development) diff --git a/project_template/tutorial/foo.cabal b/project_template/tutorial/foo.cabal --- a/project_template/tutorial/foo.cabal +++ b/project_template/tutorial/foo.cabal @@ -19,9 +19,9 @@ bytestring >= 0.9.1 && < 0.10, MonadCatchIO-transformers >= 0.2.1 && < 0.3, mtl >= 2 && < 3, - snap == 0.6.*, - snap-core == 0.6.*, - snap-server == 0.6.* + snap == 0.7.*, + snap-core == 0.7.*, + snap-server == 0.7.* if impl(ghc >= 6.12.0) ghc-options: -threaded -Wall -fwarn-tabs -funbox-strict-fields -O2 diff --git a/project_template/tutorial/src/Tutorial.lhs b/project_template/tutorial/src/Tutorial.lhs --- a/project_template/tutorial/src/Tutorial.lhs +++ b/project_template/tutorial/src/Tutorial.lhs @@ -266,9 +266,11 @@ This completes a full working application. We did leave out a little dummy code for the Foo and Bar snaplets. This code is included in Part2.hs. For -more information look in our API documentation. No really, that wasn't a -joke. The API docs are written as prose. It is written to be very easy to -read, while having the benefit of including all the actual type signatures. +more information look in our [API +documentation](http://hackage.haskell.org/packages/archive/snap/0.6.0.2/doc/html/Snap-Snaplet.html). +No really, that wasn't a joke. The API docs are written as prose. It is +written to be very easy to read, while having the benefit of including all the +actual type signatures. Filesystem Data and Automatic Installation ========================================== diff --git a/snap.cabal b/snap.cabal --- a/snap.cabal +++ b/snap.cabal @@ -1,5 +1,5 @@ name: snap -version: 0.6.0.2 +version: 0.7 synopsis: Snap: A Haskell Web Framework: project starter executable and glue code library description: Snap Framework project starter executable and glue code library license: BSD3 @@ -9,7 +9,7 @@ build-type: Simple cabal-version: >= 1.8 homepage: http://snapframework.com/ -category: Web +category: Web, Snap extra-source-files: CONTRIBUTORS, @@ -50,13 +50,10 @@ Library hs-source-dirs: src - if flag(hint) - exposed-modules: - Snap.Loader.Devel - exposed-modules: Snap, - Snap.Loader.Prod + Snap.Loader.Prod, + Snap.Loader.Devel, Snap.Snaplet, Snap.Snaplet.Heist, Snap.Snaplet.Auth, @@ -72,9 +69,6 @@ Data.RBAC.Internal.RoleMap, Data.RBAC.Internal.Rule, Data.RBAC.Internal.Types, - Snap.Loader.Devel.Evaluator, - Snap.Loader.Devel.Signal, - Snap.Loader.Devel.TreeWatcher, Snap.Snaplet.Auth.AuthManager, Snap.Snaplet.Auth.Types, Snap.Snaplet.Auth.Handlers, @@ -89,50 +83,59 @@ Snap.Snaplet.Session.SecureCookie, Snap.Snaplet.Session.SessionManager - if impl(ghc >= 7.0) && impl(ghc < 7.4) + if flag(hint) + other-modules: + Snap.Loader.Devel.Evaluator, + Snap.Loader.Devel.Signal, + Snap.Loader.Devel.TreeWatcher + + cpp-options: -DHINT_ENABLED + build-depends: - aeson-native >= 0.3 && < 0.4 - else + hint >= 0.3.3.1 && < 0.4 + + if !os(windows) build-depends: - aeson >= 0.3.2 && < 0.4 + unix >= 2.2.0.0 && < 2.6 build-depends: - Crypto >= 4.2 && < 4.3, - MonadCatchIO-transformers >= 0.2 && < 0.3, - attoparsec (>= 0.8.0.2 && < 0.9) || - (>= 0.9.1.1 && < 0.10), - base >= 4 && < 5, - bytestring >= 0.9.1 && < 0.10, - cereal >= 0.3 && < 0.4, - clientsession >= 0.7.2 && < 0.8, - configurator >= 0.1 && < 0.2, - containers >= 0.3 && < 0.5, - directory >= 1.0 && < 1.2, - directory-tree >= 0.10 && < 0.11, - data-lens >= 2.0.1 && < 2.1, - data-lens-template >= 2.1 && < 2.2, - filepath >= 1.1 && < 1.3, - hashable >= 1.1 && < 1.2, - heist >= 0.6 && < 0.7, - logict >= 0.4.2 && < 0.6, - mtl > 2.0 && < 2.1, - mwc-random >= 0.8 && < 0.11, - old-time >= 1.0 && < 1.1, - pwstore-fast >= 2.2 && < 2.3, - safe >= 0.3 && < 0.4, - snap-core >= 0.6 && < 0.7, - snap-server >= 0.6 && < 0.7, - stm >= 2.2 && < 2.3, - syb >= 0.1 && < 0.4, - template-haskell >= 2.2 && < 2.7, - text >= 0.11 && < 0.12, - time >= 1.1 && < 1.5, - transformers >= 0.2 && < 0.3, - unordered-containers >= 0.1.4 && < 0.2, - utf8-string >= 0.3 && < 0.4, - vector >= 0.7.1 && < 0.10, - vector-algorithms >= 0.4 && < 0.6, - xmlhtml >= 0.1 && < 0.2 + Crypto >= 4.2 && < 4.3, + MonadCatchIO-transformers >= 0.2 && < 0.3, + aeson >= 0.4 && < 0.5, + attoparsec >= 0.10 && < 0.11, + base >= 4 && < 5, + bytestring >= 0.9.1 && < 0.10, + cereal >= 0.3 && < 0.4, + clientsession >= 0.7.3.6 && <0.8, + configurator >= 0.1 && < 0.3, + containers >= 0.3 && < 0.5, + directory >= 1.0 && < 1.2, + directory-tree >= 0.10 && < 0.11, + data-lens >= 2.0.1 && < 2.1, + data-lens-template >= 2.1 && < 2.2, + filepath >= 1.1 && < 1.3, + hashable >= 1.1 && < 1.2, + heist >= 0.7 && < 0.8, + logict >= 0.4.2 && < 0.6, + mtl > 2.0 && < 2.1, + mwc-random >= 0.8 && < 0.11, + old-time >= 1.0 && < 1.1, + pwstore-fast >= 2.2 && < 2.3, + safe >= 0.3 && < 0.4, + skein >= 0.1.0.3 && < 0.2, + snap-core >= 0.7 && < 0.8, + snap-server >= 0.7 && < 0.8, + stm >= 2.2 && < 2.3, + syb >= 0.1 && < 0.4, + template-haskell >= 2.2 && < 2.7, + text >= 0.11 && < 0.12, + time >= 1.1 && < 1.5, + transformers >= 0.2 && < 0.3, + unordered-containers >= 0.1.4 && < 0.2, + utf8-string >= 0.3 && < 0.4, + vector >= 0.7.1 && < 0.10, + vector-algorithms >= 0.4 && < 0.6, + xmlhtml >= 0.1 && < 0.2 extensions: BangPatterns, @@ -153,14 +156,6 @@ TypeOperators, TypeSynonymInstances - if flag(hint) - build-depends: - hint >= 0.3.3.1 && < 0.4 - - if !os(windows) - build-depends: - unix >= 2.2.0.0 && < 2.6 - if impl(ghc >= 6.12.0) ghc-options: -Wall -fwarn-tabs -funbox-strict-fields -O2 -fno-warn-orphans -fno-warn-unused-do-bind @@ -182,7 +177,7 @@ directory-tree >= 0.10 && < 0.11, filepath >= 1.1 && < 1.3, old-time >= 1.0 && < 1.1, - snap-server >= 0.6 && < 0.7, + snap-server >= 0.7 && < 0.8, template-haskell >= 2.2 && < 2.7, text >= 0.11 && < 0.12 diff --git a/src/Snap/Loader/Devel.hs b/src/Snap/Loader/Devel.hs --- a/src/Snap/Loader/Devel.hs +++ b/src/Snap/Loader/Devel.hs @@ -1,4 +1,5 @@ {-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE CPP #-} -- | This module includes the machinery necessary to use hint to load -- action code dynamically. It includes a Template Haskell function -- to gather the necessary compile-time information about code @@ -8,6 +9,7 @@ ( loadSnapTH ) where +#ifdef HINT_ENABLED import Control.Monad (liftM2) import Data.Char (isAlphaNum) @@ -23,11 +25,13 @@ import System.Environment (getArgs) ------------------------------------------------------------------------------- import Snap.Core import Snap.Loader.Devel.Signal import Snap.Loader.Devel.Evaluator import Snap.Loader.Devel.TreeWatcher +#else +import Language.Haskell.TH +#endif ------------------------------------------------------------------------------ -- | This function derives all the information necessary to use the @@ -62,14 +66,20 @@ -> [String] -- ^ a list of directories to watch in addition -- to those containing code -> Q Exp +#ifndef HINT_ENABLED +loadSnapTH _ _ _ = fail $ "Snap was built without hint support. Hint " ++ + "support is necessary for development mode. " ++ + "Please reinstall snap with hint support.\n\n " ++ + " cabal install snap -fhint\n\n" +#else loadSnapTH initializer action additionalWatchDirs = do args <- runIO getArgs let opts = getHintOpts args srcPaths = additionalWatchDirs ++ getSrcPaths args - -- The first line is an extra type check to ensure the provided - -- names refer to expressions with the correct types + -- The first line is an extra type check to ensure the arguments + -- provided have the the correct types [| do let _ = $initializer >>= $(varE action) v <- $initializer (handler, cleanup) <- hintSnap opts actMods srcPaths loadStr v @@ -178,3 +188,4 @@ format (WontCompile errs) = "Compile errors:\r\n\r\n" ++ (intercalate "\r\n" $ nub $ map errMsg errs) +#endif diff --git a/src/Snap/Snaplet.hs b/src/Snap/Snaplet.hs --- a/src/Snap/Snaplet.hs +++ b/src/Snap/Snaplet.hs @@ -64,6 +64,8 @@ , getSnapletDescription , getSnapletUserConfig , getSnapletRootURL + , getRoutePattern + , setRoutePattern -- * Snaplet state manipulation -- $snapletState @@ -183,7 +185,7 @@ -- > -- snapletValue is defined in the framework: -- > snapletValue :: Lens (Snaplet a) a -- > --- > appQuuxLens :: Lens App (Snaplet Quux) +-- > appQuuxLens :: Lens App Quux -- > appQuuxLens = quux . snapletValue . foo -- -- Lens composition is very similar to function composition, but it gives you diff --git a/src/Snap/Snaplet/Heist.hs b/src/Snap/Snaplet/Heist.hs --- a/src/Snap/Snaplet/Heist.hs +++ b/src/Snap/Snaplet/Heist.hs @@ -14,6 +14,7 @@ -- * Initializer Functions -- $initializerSection , heistInit + , heistInit' , addTemplates , addTemplatesAt , modifyHeistTS @@ -52,7 +53,8 @@ import Snap.Snaplet import qualified Snap.Snaplet.HeistNoClass as Unclassed -import Snap.Snaplet.HeistNoClass (Heist, heistInit, clearHeistCache) +import Snap.Snaplet.HeistNoClass (Heist, heistInit + ,heistInit', clearHeistCache) ------------------------------------------------------------------------------ @@ -67,7 +69,7 @@ -- > instance HasHeist App where heistLens = subSnaplet heist -- > -- > appInit = makeSnaplet "app" "" Nothing $ do --- > h <- nestSnaplet "heist" $ heistInit "templates" +-- > h <- nestSnaplet "heist" heist $ heistInit "templates" -- > addSplices myAppSplices -- > return $ App h class HasHeist b where @@ -85,21 +87,31 @@ -- | Adds templates to the Heist TemplateState. Other snaplets should use -- this function to add their own templates. The templates are automatically -- read from the templates directory in the current snaplet's filesystem root. -addTemplates :: HasHeist b => ByteString -> Initializer b v () +addTemplates :: HasHeist b + => ByteString + -- ^ Path to templates (also the url prefix for their routes) + -> Initializer b v () addTemplates pfx = withTop' heistLens (Unclassed.addTemplates pfx) ------------------------------------------------------------------------------ -- | Adds templates to the Heist TemplateState, and lets you specify where -- they are found in the filesystem. -addTemplatesAt :: HasHeist b => ByteString -> FilePath -> Initializer b v () +addTemplatesAt :: HasHeist b + => ByteString + -- ^ URL prefix for template routes + -> FilePath + -- ^ Path to templates + -> Initializer b v () addTemplatesAt pfx p = withTop' heistLens (Unclassed.addTemplatesAt pfx p) ------------------------------------------------------------------------------ -- | Allows snaplets to add splices. addSplices :: (HasHeist b) - => [(Text, Unclassed.SnapletSplice b v)] -> Initializer b v () + => [(Text, Unclassed.SnapletSplice b v)] + -- ^ Splices to bind + -> Initializer b v () addSplices = Unclassed.addSplices' heistLens @@ -109,6 +121,7 @@ -- like the cache tag. modifyHeistTS :: (HasHeist b) => (TemplateState (Handler b b) -> TemplateState (Handler b b)) + -- ^ TemplateState modifying function -> Initializer b v () modifyHeistTS = Unclassed.modifyHeistTS' heistLens @@ -117,6 +130,7 @@ -- | Runs a function on with the Heist snaplet's 'TemplateState'. withHeistTS :: (HasHeist b) => (TemplateState (Handler b b) -> a) + -- ^ TemplateState function to run -> Handler b v a withHeistTS = Unclassed.withHeistTS' heistLens @@ -129,14 +143,22 @@ ------------------------------------------------------------------------------ -- | Renders a template as text\/html. If the given template is not found, -- this returns 'empty'. -render :: HasHeist b => ByteString -> Handler b v () +render :: HasHeist b + => ByteString + -- ^ Template name + -> Handler b v () render t = withTop' heistLens (Unclassed.render t) ------------------------------------------------------------------------------ -- | Renders a template as the given content type. If the given template -- is not found, this returns 'empty'. -renderAs :: HasHeist b => ByteString -> ByteString -> Handler b v () +renderAs :: HasHeist b + => ByteString + -- ^ Content type to render with + -> ByteString + -- ^ Template name + -> Handler b v () renderAs ct t = withTop' heistLens (Unclassed.renderAs ct t) @@ -150,7 +172,10 @@ ------------------------------------------------------------------------------ -- | Analogous to 'fileServeSingle'. If the given template is not found, -- this throws an error. -heistServeSingle :: HasHeist b => ByteString -> Handler b v () +heistServeSingle :: HasHeist b + => ByteString + -- ^ Template name + -> Handler b v () heistServeSingle t = withTop' heistLens (Unclassed.heistServeSingle t) @@ -159,7 +184,9 @@ -- a common combination of heistLocal, bindSplices, and render. renderWithSplices :: HasHeist b => ByteString + -- ^ Template name -> [(Text, Unclassed.SnapletSplice b v)] + -- ^ Splices to bind -> Handler b v () renderWithSplices = Unclassed.renderWithSplices' heistLens @@ -169,7 +196,9 @@ -- 'TemplateState'. withSplices :: HasHeist b => [(Text, Unclassed.SnapletSplice b v)] + -- ^ Splices to bind -> Handler b v a + -- ^ Handler to run -> Handler b v a withSplices = Unclassed.withSplices' heistLens @@ -182,7 +211,9 @@ -- > heistLocal (bindSplices mySplices) handlerThatNeedsSplices heistLocal :: HasHeist b => (TemplateState (Handler b b) -> TemplateState (Handler b b)) + -- ^ TemplateState modifying function -> Handler b v a + -- ^ Handler to run -> Handler b v a heistLocal = Unclassed.heistLocal' heistLens diff --git a/src/Snap/Snaplet/HeistNoClass.hs b/src/Snap/Snaplet/HeistNoClass.hs --- a/src/Snap/Snaplet/HeistNoClass.hs +++ b/src/Snap/Snaplet/HeistNoClass.hs @@ -7,6 +7,7 @@ module Snap.Snaplet.HeistNoClass ( Heist , heistInit + , heistInit' , clearHeistCache , addTemplates @@ -203,33 +204,65 @@ ------------------------------------------------------------------------------ --- | The 'Initializer' for 'Heist'. +-- | The 'Initializer' for 'Heist'. This function is a convenience wrapper +-- around `heistInit'` that uses the default `emptyTemplateState` from Heist +-- and sets up routes for all the templates. heistInit :: FilePath + -- ^ Path to templates -> SnapletInit b (Heist b) -heistInit templateDir = +heistInit templateDir = do makeSnaplet "heist" "" Nothing $ do - (cacheFunc, cts) <- liftIO mkCacheTag - let origTs = cacheFunc emptyTemplateState - ts <- liftIO $ loadTemplates templateDir origTs >>= - either error return + hs <- heistInitWorker templateDir emptyTemplateState addRoutes [ ("", heistServe) ] - printInfo $ T.pack $ unwords - [ "...loaded" - , (show $ length $ templateNames ts) - , "templates" - ] + return hs - return $ Heist ts cts +------------------------------------------------------------------------------ +-- | A lower level 'Initializer' for 'Heist'. This initializer requires you +-- to specify the initial TemplateState. It also does not add any routes for +-- templates, allowing you complete control over which templates get routed. +heistInit' :: FilePath + -- ^ Path to templates + -> TemplateState (Handler b b) + -- ^ Initial TemplateState + -> SnapletInit b (Heist b) +heistInit' templateDir initialTemplateState = + makeSnaplet "heist" "" Nothing $ + heistInitWorker templateDir initialTemplateState -addTemplates :: ByteString -> Initializer b (Heist b) () + +------------------------------------------------------------------------------ +-- | Internal worker function used by variantsof heistInit. This is necessary +-- because of the divide between SnapletInit and Initializer. +heistInitWorker :: FilePath + -> TemplateState (Handler b b) + -> Initializer b v (Heist b) +heistInitWorker templateDir initialTemplateState = do + (cacheFunc, cts) <- liftIO mkCacheTag + let origTs = cacheFunc initialTemplateState + ts <- liftIO $ loadTemplates templateDir origTs >>= + either error return + printInfo $ T.pack $ unwords + [ "...loaded" + , (show $ length $ templateNames ts) + , "templates" + ] + + return $ Heist ts cts + + +addTemplates :: ByteString + -- ^ Path to templates (also the url prefix for their routes) + -> Initializer b (Heist b) () addTemplates urlPrefix = do snapletPath <- getSnapletFilePath addTemplatesAt urlPrefix (snapletPath "templates") addTemplatesAt :: ByteString + -- ^ URL prefix for template routes -> FilePath + -- ^ Path to templates -> Initializer b (Heist b) () addTemplatesAt urlPrefix templateDir = do ts <- liftIO $ loadTemplates templateDir emptyTemplateState diff --git a/src/Snap/Snaplet/Internal/Initializer.hs b/src/Snap/Snaplet/Internal/Initializer.hs --- a/src/Snap/Snaplet/Internal/Initializer.hs +++ b/src/Snap/Snaplet/Internal/Initializer.hs @@ -347,8 +347,14 @@ addRoutes rs = do l <- getLens ctx <- iGets (_scRouteContext . _curConfig) - let rs' = map (\(r,h) -> (buildPath (r:ctx), withTop' l h)) rs + let modRoute (r,h) = ( buildPath (r:ctx) + , setPattern r >> withTop' l h) + let rs' = map modRoute rs iModify (\v -> modL handlers (++rs') v) + where + setPattern r = do + p <- getRoutePattern + when (isNothing p) $ setRoutePattern r ------------------------------------------------------------------------------ @@ -431,7 +437,8 @@ runInitializer mvar b@(Initializer i) = do userConfig <- load [Optional "snaplet.cfg"] let builtinHandlers = [("/admin/reload", reloadSite)] - let cfg = SnapletConfig [] "" Nothing "" userConfig [] (mkReloader mvar b) + let cfg = SnapletConfig [] "" Nothing "" userConfig [] Nothing + (mkReloader mvar b) logRef <- newIORef "" ((res, s), (Hook hook)) <- runWriterT $ LT.runLensT i id $ InitializerState True (return ()) builtinHandlers id cfg logRef diff --git a/src/Snap/Snaplet/Internal/Types.hs b/src/Snap/Snaplet/Internal/Types.hs --- a/src/Snap/Snaplet/Internal/Types.hs +++ b/src/Snap/Snaplet/Internal/Types.hs @@ -7,9 +7,9 @@ module Snap.Snaplet.Internal.Types where -import Prelude hiding ((.)) +import Prelude hiding ((.), id) import Control.Applicative -import Control.Category ((.)) +import Control.Category ((.), id) import Control.Monad.CatchIO hiding (Handler) import Control.Monad.Reader import Control.Monad.State.Class @@ -40,6 +40,9 @@ , _scDescription :: Text , _scUserConfig :: Config , _scRouteContext :: [ByteString] + , _scRoutePattern :: Maybe ByteString + -- ^ Holds the actual route pattern passed to addRoutes for the current + -- handler. Nothing during initialization and before route dispatech. , _reloader :: IO (Either String String) -- might change } @@ -250,6 +253,22 @@ with' !l (Handler !m) = Handler $ L.with l m withTop' !l (Handler m) = Handler $ L.withTop l m getOpaqueConfig = Handler $ gets _snapletConfig + + +------------------------------------------------------------------------------ +-- | Gets the route pattern that matched for the handler. This lets you find +-- out exactly which of the strings you used in addRoutes matched. +getRoutePattern :: Handler b v (Maybe ByteString) +getRoutePattern = withTop' id $ liftM _scRoutePattern getOpaqueConfig + + +------------------------------------------------------------------------------ +-- | Sets the route pattern that matched for the handler. Use this when to +-- override the default pattern which is the key to the alist passed to +-- addRoutes. +setRoutePattern :: ByteString -> Handler b v () +setRoutePattern p = withTop' id $ + modifySnapletState (setL (scRoutePattern . snapletConfig) (Just p)) ------------------------------------------------------------------------------ diff --git a/test/snap-testsuite.cabal b/test/snap-testsuite.cabal --- a/test/snap-testsuite.cabal +++ b/test/snap-testsuite.cabal @@ -12,7 +12,7 @@ HUnit >= 1.2 && < 2, MonadCatchIO-transformers >= 0.2 && < 0.3, QuickCheck >= 2.3.0.2, - attoparsec (>= 0.8 && < 0.10), + attoparsec >= 0.10 && <0.11, base >= 4 && < 5, bytestring >= 0.9 && < 0.10, containers >= 0.3, @@ -21,12 +21,12 @@ directory, directory-tree >= 0.10 && < 0.11, filepath, - heist >= 0.6 && < 0.7, - http-enumerator >= 0.6.5.3 && < 0.8, + heist >= 0.7 && < 0.8, + http-enumerator >= 0.7.1.7 && < 0.8, mtl >= 2, process == 1.*, - snap-core >= 0.6 && < 0.7, - snap-server >= 0.6 && < 0.7, + snap-core >= 0.7 && < 0.8, + snap-server >= 0.7 && < 0.8, test-framework >= 0.4 && < 0.5, test-framework-hunit >= 0.2.5 && < 0.3, test-framework-quickcheck2 >= 0.2.6 && < 0.3, @@ -66,12 +66,12 @@ build-depends: MonadCatchIO-transformers >= 0.2 && < 0.3, - attoparsec (>= 0.8 && < 0.10), + attoparsec >= 0.10 && <0.11, base >= 4 && < 5, bytestring >= 0.9 && < 0.10, cereal >= 0.3, - clientsession >= 0.6.0, - configurator == 0.1.*, + clientsession >= 0.7.3.6 && <0.8, + configurator >= 0.1 && < 0.3, containers >= 0.3, data-lens >= 2.0.1 && < 2.1, data-lens-template >= 2.1.1 && < 2.2, @@ -79,12 +79,12 @@ directory-tree >= 0.10 && < 0.11, filepath, hashable >= 1.1, - heist >= 0.6 && < 0.7, + heist >= 0.7 && < 0.8, mtl >= 2, mwc-random >= 0.8, process == 1.*, - snap-core >= 0.6 && < 0.7, - snap-server >= 0.6 && < 0.7, + snap-core >= 0.7 && < 0.8, + snap-server >= 0.7 && < 0.8, syb >= 0.1, time >= 1.1, text >= 0.11 && < 0.12, @@ -122,7 +122,7 @@ build-depends: MonadCatchIO-transformers >= 0.2 && < 0.3, - attoparsec (>= 0.8 && < 0.10), + attoparsec >= 0.10 && <0.11, base >= 4 && < 5, bytestring >= 0.9 && < 0.10, containers >= 0.3, @@ -131,11 +131,11 @@ directory, directory-tree >= 0.10 && < 0.11, filepath, - heist >= 0.6 && < 0.7, + heist >= 0.7 && < 0.8, mtl >= 2, process == 1.*, - snap-core >= 0.6 && < 0.7, - snap-server >= 0.6 && < 0.7, + snap-core >= 0.7 && < 0.8, + snap-server >= 0.7 && < 0.8, text >= 0.11 && < 0.12, transformers >= 0.2, utf8-string >= 0.3 && < 0.4,