b810fe3 · hakyll · git.iko.soy

hakyll.cabal+6

compare with master

unifiedsplit

@@ -165,6 +165,7 @@ Library

165 random >= 1.0 && < 1.2,

166 regex-base >= 0.93 && < 0.94,

167 regex-tdfa >= 1.1 && < 1.3,

168+ resourcet >= 1.1 && < 1.2,

168 tagsoup >= 0.13.1 && < 0.14,

169 tagsoup >= 0.13.1 && < 0.14,

169 text >= 0.11 && < 1.3,

170 text >= 0.11 && < 1.3,

170 time >= 1.4 && < 1.6,

171 time >= 1.4 && < 1.6,

@@ -254,6 +255,7 @@ Test-suite hakyll-tests

254 random >= 1.0 && < 1.2,

255 random >= 1.0 && < 1.2,

255 regex-base >= 0.93 && < 0.94,

256 regex-base >= 0.93 && < 0.94,

256 regex-tdfa >= 1.1 && < 1.3,

257 regex-tdfa >= 1.1 && < 1.3,

258+ resourcet >= 1.1 && < 1.2,

257 tagsoup >= 0.13.1 && < 0.14,

259 tagsoup >= 0.13.1 && < 0.14,

258 text >= 0.11 && < 1.3,

260 text >= 0.11 && < 1.3,

259 time >= 1.4 && < 1.6,

261 time >= 1.4 && < 1.6,

@@ -299,3 +301,7 @@ Executable hakyll-init

299 base >= 4 && < 5,

301 base >= 4 && < 5,

300 directory >= 1.0 && < 1.3,

302 directory >= 1.0 && < 1.3,

301 filepath >= 1.0 && < 1.5

303 filepath >= 1.0 && < 1.5

304+

305+ Other-modules:

306+ Hakyll.Core.Util.File

307+ Paths_hakyll

src/Hakyll/Check.hs+32−29

@@ -8,42 +8,44 @@ module Hakyll.Check

8

9

10--------------------------------------------------------------------------------

11−import Control.Applicative ((<$>))

11+import Control.Monad (forM_)

12−import Control.Monad (forM_)

13−import Control.Monad.Reader (ask)

12+import Control.Monad.Reader (ask)

14−import Control.Monad.RWS (RWST, runRWST)

13+import Control.Monad.RWS (RWST, runRWST)

15−import Control.Monad.Trans (liftIO)

14+import Control.Monad.Trans (liftIO)

16−import Control.Monad.Writer (tell)

15+import Control.Monad.Trans.Resource (runResourceT)

16+import Control.Monad.Writer (tell)

17−import Data.List (isPrefixOf)

17+import Data.List (isPrefixOf)

18−import Data.Monoid (Monoid (..))

18+import Data.Set (Set)

19−import Data.Set (Set)

20−import qualified Data.Set as S

19+import qualified Data.Set as S

21−import Network.URI (unEscapeString)

20+import Network.URI (unEscapeString)

22−import System.Directory (doesDirectoryExist, doesFileExist)

21+import System.Directory (doesDirectoryExist,

22+ doesFileExist)

23−import System.Exit (ExitCode (..))

23+import System.Exit (ExitCode (..))

24−import System.FilePath (takeDirectory, takeExtension, (</>))

24+import System.FilePath (takeDirectory, takeExtension,

25+ (</>))

25−import qualified Text.HTML.TagSoup as TS

26+import qualified Text.HTML.TagSoup as TS

26

27

28

28--------------------------------------------------------------------------------

29--------------------------------------------------------------------------------

29#ifdef CHECK_EXTERNAL

30#ifdef CHECK_EXTERNAL

30−import Control.Exception (AsyncException (..),

31+import Control.Exception (AsyncException (..),

31− SomeException (..), handle, throw)

32+ SomeException (..), handle,

33+ throw)

32−import Control.Monad.State (get, modify)

34+import Control.Monad.State (get, modify)

33−import Data.List (intercalate)

35+import Data.List (intercalate)

34−import Data.Typeable (cast)

36+import Data.Typeable (cast)

35−import Data.Version (versionBranch)

37+import Data.Version (versionBranch)

36−import GHC.Exts (fromString)

38+import GHC.Exts (fromString)

37−import qualified Network.HTTP.Conduit as Http

39+import qualified Network.HTTP.Conduit as Http

38−import qualified Network.HTTP.Types as Http

40+import qualified Network.HTTP.Types as Http

39−import qualified Paths_hakyll as Paths_hakyll

41+import qualified Paths_hakyll as Paths_hakyll

40#endif

42#endif

41

43

42

44

43--------------------------------------------------------------------------------

45--------------------------------------------------------------------------------

44import Hakyll.Core.Configuration

46import Hakyll.Core.Configuration

45−import Hakyll.Core.Logger (Logger)

47+import Hakyll.Core.Logger (Logger)

46−import qualified Hakyll.Core.Logger as Logger

48+import qualified Hakyll.Core.Logger as Logger

47import Hakyll.Core.Util.File

49import Hakyll.Core.Util.File

48import Hakyll.Web.Html

50import Hakyll.Web.Html

49

51

@@ -196,8 +198,9 @@ checkExternalUrl url = do

196 if not needsCheck || checked

198 if not needsCheck || checked

197 then Logger.debug logger "Already checked, skipping"

199 then Logger.debug logger "Already checked, skipping"

198 else do

200 else do

199− isOk <- liftIO $ handle (failure logger) $

201+ isOk <- liftIO $ handle (failure logger) $ do

200− Http.withManager $ \mgr -> do

202+ mgr <- Http.newManager Http.tlsManagerSettings

203+ runResourceT $ do

201 request <- Http.parseUrl urlToCheck

204 request <- Http.parseUrl urlToCheck

202 response <- Http.http (settings request) mgr

205 response <- Http.http (settings request) mgr

203 let code = Http.statusCode (Http.responseStatus response)

206 let code = Http.statusCode (Http.responseStatus response)

src/Hakyll/Commands.hs−3

@@ -14,11 +14,8 @@ module Hakyll.Commands

14

15

16--------------------------------------------------------------------------------

17−import Control.Applicative

18import Control.Concurrent

17import Control.Concurrent

19−import Control.Monad (void)

20import System.Exit (ExitCode, exitWith)

18import System.Exit (ExitCode, exitWith)

21−import System.IO.Error (catchIOError)

22

19

23--------------------------------------------------------------------------------

20--------------------------------------------------------------------------------

24import qualified Hakyll.Check as Check

21import qualified Hakyll.Check as Check

src/Hakyll/Core/Compiler.hs−1

@@ -28,7 +28,6 @@ module Hakyll.Core.Compiler

28

29

30--------------------------------------------------------------------------------

31−import Control.Applicative ((<$>))

32import Control.Monad (when)

31import Control.Monad (when)

33import Data.Binary (Binary)

32import Data.Binary (Binary)

34import Data.ByteString.Lazy (ByteString)

33import Data.ByteString.Lazy (ByteString)

src/Hakyll/Core/Compiler/Internal.hs+2−4

@@ -28,12 +28,10 @@ module Hakyll.Core.Compiler.Internal

28

29

30--------------------------------------------------------------------------------

31−import Control.Applicative (Alternative (..),

31+import Control.Applicative (Alternative (..))

32− Applicative (..), (<$>))

33import Control.Exception (SomeException, handle)

32import Control.Exception (SomeException, handle)

34import Control.Monad (forM_)

33import Control.Monad (forM_)

35−import Control.Monad.Error (MonadError (..))

34+import Control.Monad.Except (MonadError (..))

36−import Data.Monoid (Monoid (..))

37import Data.Set (Set)

35import Data.Set (Set)

38import qualified Data.Set as S

36import qualified Data.Set as S

39

37

src/Hakyll/Core/Compiler/Require.hs−1

@@ -13,7 +13,6 @@ module Hakyll.Core.Compiler.Require

13

14

15--------------------------------------------------------------------------------

16−import Control.Applicative ((<$>))

17import Control.Monad (when)

16import Control.Monad (when)

18import Data.Binary (Binary)

17import Data.Binary (Binary)

19import qualified Data.Set as S

18import qualified Data.Set as S

src/Hakyll/Core/Dependencies.hs−1

@@ -8,7 +8,6 @@ module Hakyll.Core.Dependencies

8

9

10--------------------------------------------------------------------------------

11−import Control.Applicative ((<$>), (<*>))

12import Control.Monad (foldM, forM_, unless, when)

11import Control.Monad (foldM, forM_, unless, when)

13import Control.Monad.Reader (ask)

12import Control.Monad.Reader (ask)

14import Control.Monad.RWS (RWS, runRWS)

13import Control.Monad.RWS (RWS, runRWS)

src/Hakyll/Core/File.hs−1

@@ -11,7 +11,6 @@ module Hakyll.Core.File

11

12

13--------------------------------------------------------------------------------

14−import Control.Applicative ((<$>))

15import Data.Binary (Binary (..))

14import Data.Binary (Binary (..))

16import Data.Typeable (Typeable)

15import Data.Typeable (Typeable)

17import System.Directory (copyFile, doesFileExist,

16import System.Directory (copyFile, doesFileExist,

src/Hakyll/Core/Identifier.hs−1

@@ -19,7 +19,6 @@ module Hakyll.Core.Identifier

19

20

21--------------------------------------------------------------------------------

22−import Control.Applicative ((<$>), (<*>))

23import Control.DeepSeq (NFData (..))

22import Control.DeepSeq (NFData (..))

24import Data.List (intercalate)

23import Data.List (intercalate)

25import System.FilePath (dropTrailingPathSeparator, splitPath)

24import System.FilePath (dropTrailingPathSeparator, splitPath)

src/Hakyll/Core/Identifier/Pattern.hs−2

@@ -57,13 +57,11 @@ module Hakyll.Core.Identifier.Pattern

57

58

59--------------------------------------------------------------------------------

60−import Control.Applicative (pure, (<$>), (<*>))

61import Control.Arrow ((&&&), (>>>))

60import Control.Arrow ((&&&), (>>>))

62import Control.Monad (msum)

61import Control.Monad (msum)

63import Data.Binary (Binary (..), getWord8, putWord8)

62import Data.Binary (Binary (..), getWord8, putWord8)

64import Data.List (inits, isPrefixOf, tails)

63import Data.List (inits, isPrefixOf, tails)

65import Data.Maybe (isJust)

64import Data.Maybe (isJust)

66−import Data.Monoid (Monoid, mappend, mempty)

67import Data.Set (Set)

65import Data.Set (Set)

68import qualified Data.Set as S

66import qualified Data.Set as S

69

67

src/Hakyll/Core/Item.hs−2

@@ -10,10 +10,8 @@ module Hakyll.Core.Item

10

11

12--------------------------------------------------------------------------------

13−import Control.Applicative ((<$>), (<*>))

14import Data.Binary (Binary (..))

13import Data.Binary (Binary (..))

15import Data.Foldable (Foldable (..))

14import Data.Foldable (Foldable (..))

16−import Data.Traversable (Traversable (..))

17import Data.Typeable (Typeable)

15import Data.Typeable (Typeable)

18import Prelude hiding (foldr)

16import Prelude hiding (foldr)

19

17

src/Hakyll/Core/Logger.hs−1

@@ -13,7 +13,6 @@ module Hakyll.Core.Logger

13

14

15--------------------------------------------------------------------------------

16−import Control.Applicative (pure, (<$>), (<*>))

17import Control.Concurrent (forkIO)

16import Control.Concurrent (forkIO)

18import Control.Concurrent.Chan (Chan, newChan, readChan, writeChan)

17import Control.Concurrent.Chan (Chan, newChan, readChan, writeChan)

19import Control.Concurrent.MVar (MVar, newEmptyMVar, putMVar, takeMVar)

18import Control.Concurrent.MVar (MVar, newEmptyMVar, putMVar, takeMVar)

src/Hakyll/Core/Provider/Internal.hs−2

@@ -20,7 +20,6 @@ module Hakyll.Core.Provider.Internal

20

21

22--------------------------------------------------------------------------------

23−import Control.Applicative ((<$>), (<*>))

24import Control.DeepSeq (NFData (..), deepseq)

23import Control.DeepSeq (NFData (..), deepseq)

25import Control.Monad (forM)

24import Control.Monad (forM)

26import Data.Binary (Binary (..))

25import Data.Binary (Binary (..))

@@ -28,7 +27,6 @@ import qualified Data.ByteString.Lazy as BL

28import Data.Map (Map)

27import Data.Map (Map)

29import qualified Data.Map as M

28import qualified Data.Map as M

30import Data.Maybe (fromMaybe)

29import Data.Maybe (fromMaybe)

31−import Data.Monoid (mempty)

32import Data.Set (Set)

30import Data.Set (Set)

33import qualified Data.Set as S

31import qualified Data.Set as S

34import Data.Time (Day (..), UTCTime (..))

32import Data.Time (Day (..), UTCTime (..))

src/Hakyll/Core/Provider/Metadata.hs−5

@@ -11,13 +11,10 @@ module Hakyll.Core.Provider.Metadata

11

12

13--------------------------------------------------------------------------------

14−import Control.Applicative

15import Control.Arrow (second)

14import Control.Arrow (second)

16import Control.Exception (Exception, throwIO)

15import Control.Exception (Exception, throwIO)

17import Control.Monad (guard)

16import Control.Monad (guard)

18import qualified Data.ByteString.Char8 as BC

17import qualified Data.ByteString.Char8 as BC

19−import qualified Data.HashMap.Strict as HMS

20−import Data.List (intercalate)

21import Data.List.Extended (breakWhen)

18import Data.List.Extended (breakWhen)

22import qualified Data.Map as M

19import qualified Data.Map as M

23import Data.Maybe (fromMaybe)

20import Data.Maybe (fromMaybe)

@@ -28,8 +25,6 @@ import qualified Data.Yaml as Yaml

28import Hakyll.Core.Identifier

25import Hakyll.Core.Identifier

29import Hakyll.Core.Metadata

26import Hakyll.Core.Metadata

30import Hakyll.Core.Provider.Internal

27import Hakyll.Core.Provider.Internal

31−import Hakyll.Core.Util.Parser

32−import Hakyll.Core.Util.String

33import System.IO as IO

28import System.IO as IO

34

29

35

30

src/Hakyll/Core/Rules.hs−2

@@ -33,13 +33,11 @@ module Hakyll.Core.Rules

33

34

35--------------------------------------------------------------------------------

36−import Control.Applicative ((<$>))

37import Control.Monad.Reader (ask, local)

36import Control.Monad.Reader (ask, local)

38import Control.Monad.State (get, modify, put)

37import Control.Monad.State (get, modify, put)

39import Control.Monad.Trans (liftIO)

38import Control.Monad.Trans (liftIO)

40import Control.Monad.Writer (censor, tell)

39import Control.Monad.Writer (censor, tell)

41import Data.Maybe (fromMaybe)

40import Data.Maybe (fromMaybe)

42−import Data.Monoid (mempty)

43import qualified Data.Set as S

41import qualified Data.Set as S

44

42

45

43

src/Hakyll/Core/Rules/Internal.hs−2

@@ -12,12 +12,10 @@ module Hakyll.Core.Rules.Internal

12

13

14--------------------------------------------------------------------------------

15−import Control.Applicative (Applicative, (<$>))

16import Control.Monad.Reader (ask)

15import Control.Monad.Reader (ask)

17import Control.Monad.RWS (RWST, runRWST)

16import Control.Monad.RWS (RWST, runRWST)

18import Control.Monad.Trans (liftIO)

17import Control.Monad.Trans (liftIO)

19import qualified Data.Map as M

18import qualified Data.Map as M

20−import Data.Monoid (Monoid, mappend, mempty)

21import Data.Set (Set)

19import Data.Set (Set)

22

20

23

21

src/Hakyll/Core/Runtime.hs+3−3

@@ -6,7 +6,7 @@ module Hakyll.Core.Runtime

6

7--------------------------------------------------------------------------------

8import Control.Monad (unless)

9−import Control.Monad.Error (ErrorT, runErrorT, throwError)

9+import Control.Monad.Except (ExceptT, runExceptT, throwError)

10import Control.Monad.Reader (ask)

11import Control.Monad.RWS (RWST, runRWST)

12import Control.Monad.State (get, modify)

@@ -75,7 +75,7 @@ run config logger rules = do

75 }

76

77 -- Run the program and fetch the resulting state

78− result <- runErrorT $ runRWST build read' state

78+ result <- runExceptT $ runRWST build read' state

79 case result of

80 Left e -> do

81 Logger.error logger e

@@ -115,7 +115,7 @@ data RuntimeState = RuntimeState

115

116

117--------------------------------------------------------------------------------

118−type Runtime a = RWST RuntimeRead () RuntimeState (ErrorT String IO) a

118+type Runtime a = RWST RuntimeRead () RuntimeState (ExceptT String IO) a

119

120

121--------------------------------------------------------------------------------

src/Hakyll/Core/Store.hs−1

@@ -16,7 +16,6 @@ module Hakyll.Core.Store

16

17

18--------------------------------------------------------------------------------

19−import Control.Applicative ((<$>))

20import Control.Exception (IOException, handle)

19import Control.Exception (IOException, handle)

21import qualified Crypto.Hash.MD5 as MD5

20import qualified Crypto.Hash.MD5 as MD5

22import Data.Binary (Binary, decode, encodeFile)

21import Data.Binary (Binary, decode, encodeFile)

src/Hakyll/Core/UnixFilter.hs−1

@@ -16,7 +16,6 @@ import Control.Monad (forM_)

16import Data.ByteString.Lazy (ByteString)

17import qualified Data.ByteString.Lazy as LB

18import Data.IORef (newIORef, readIORef, writeIORef)

19−import Data.Monoid (Monoid, mempty)

20import System.Exit (ExitCode (..))

19import System.Exit (ExitCode (..))

21import System.IO (Handle, hClose, hFlush, hGetContents,

20import System.IO (Handle, hClose, hFlush, hGetContents,

22 hPutStr, hSetEncoding, localeEncoding)

21 hPutStr, hSetEncoding, localeEncoding)

src/Hakyll/Core/Util/File.hs−1

@@ -8,7 +8,6 @@ module Hakyll.Core.Util.File

8

9

10--------------------------------------------------------------------------------

11−import Control.Applicative ((<$>))

12import Control.Monad (filterM, forM, when)

11import Control.Monad (filterM, forM, when)

13import System.Directory (createDirectoryIfMissing,

12import System.Directory (createDirectoryIfMissing,

14 doesDirectoryExist, getDirectoryContents,

13 doesDirectoryExist, getDirectoryContents,

src/Hakyll/Core/Util/Parser.hs+1−1

@@ -7,7 +7,7 @@ module Hakyll.Core.Util.Parser

7

8

9--------------------------------------------------------------------------------

10−import Control.Applicative ((<$>), (<*>), (<|>))

10+import Control.Applicative ((<|>))

11import Control.Monad (mzero)

12import qualified Text.Parsec as P

13import Text.Parsec.String (Parser)

src/Hakyll/Web/CompressCss.hs−1

@@ -8,7 +8,6 @@ module Hakyll.Web.CompressCss

8

9

10--------------------------------------------------------------------------------

11−import Control.Applicative ((<$>))

12import Data.Char (isSpace)

11import Data.Char (isSpace)

13import Data.List (isPrefixOf)

12import Data.List (isPrefixOf)

14

13

src/Hakyll/Web/Feed.hs−1

@@ -25,7 +25,6 @@ module Hakyll.Web.Feed

25

26--------------------------------------------------------------------------------

27import Control.Monad ((<=<))

28−import Data.Monoid (mconcat)

29

28

30

29

31--------------------------------------------------------------------------------

30--------------------------------------------------------------------------------

src/Hakyll/Web/Paginate.hs−1

@@ -13,7 +13,6 @@ module Hakyll.Web.Paginate

13--------------------------------------------------------------------------------

14import Control.Monad (forM_)

15import qualified Data.Map as M

16−import Data.Monoid (mconcat)

17import qualified Data.Set as S

16import qualified Data.Set as S

18

17

19

18

src/Hakyll/Web/Pandoc.hs−2

@@ -22,9 +22,7 @@ module Hakyll.Web.Pandoc

22

23

24--------------------------------------------------------------------------------

25−import Control.Applicative ((<$>))

26import qualified Data.Set as S

25import qualified Data.Set as S

27−import Data.Traversable (traverse)

28import Text.Pandoc

26import Text.Pandoc

29import Text.Pandoc.Error (PandocError (..))

27import Text.Pandoc.Error (PandocError (..))

30

28

src/Hakyll/Web/Template.hs+7−8

@@ -54,7 +54,7 @@

54-- The @for@ macro is used for enumerating 'Context' elements that are

55-- lists, i.e. constructed using the 'listField' function. Assume that

56-- in a context we have an element @listField \"key\" c itms@. Then

57−-- the snippet

57+-- the snippet

58--

59-- > $for(key)$

60-- > $x$

@@ -70,21 +70,21 @@

70--

71-- > listField "things" (field "thing" (return . itemBody))

72-- > (sequence [makeItem "fruits", makeItem "vegetables"])

73−--

73+--

74-- and a template

75--

76-- > I like

77-- > $for(things)$

78−-- > fresh $thing$$sep$, and

78+-- > fresh $thing$$sep$, and

79-- > $endfor$

80--

81-- the resulting page would look like

82--

83-- > <p>

84-- > I like

85−-- >

85+-- >

86−-- > fresh fruits, and

86+-- > fresh fruits, and

87−-- >

87+-- >

88-- > fresh vegetables

89-- > </p>

90--

@@ -129,9 +129,8 @@ module Hakyll.Web.Template

129

130--------------------------------------------------------------------------------

131import Control.Monad (liftM)

132−import Control.Monad.Error (MonadError (..))

132+import Control.Monad.Except (MonadError (..))

133import Data.List (intercalate)

134−import Data.Monoid (mappend)

135import Prelude hiding (id)

134import Prelude hiding (id)

136

135

137

136

src/Hakyll/Web/Template/Internal.hs+1−1

@@ -12,7 +12,7 @@ module Hakyll.Web.Template.Internal

12

13

14--------------------------------------------------------------------------------

15−import Control.Applicative (pure, (<$), (<$>), (<*>), (<|>))

15+import Control.Applicative ((<|>))

16import Control.Monad (void)

17import Data.Binary (Binary, get, getWord8, put, putWord8)

18import Data.Typeable (Typeable)