master..b4ad53d · typeable/file-embed

git.iko.soy/typeable/file-embed

on b4ad53d help sign in

.github/workflows/tests.ymldeleted−32

since splitsnapshots

unifiedsplit

@@ -1,32 +0,0 @@

1−name: Tests

2−

3−on: [pull_request, push]

4−

5−jobs:

6− build:

7− name: CI

8− runs-on: ${{ matrix.os }}

9− strategy:

10− fail-fast: false

11− matrix:

12− os: [ubuntu-latest, macos-latest, windows-latest]

13− resolver: [nightly, lts-15, lts-14, lts-12, lts-11, lts-9]

14−

15− steps:

16− - name: Clone project

17− uses: actions/checkout@v2

18−

19− - name: Cache dependencies

20− uses: actions/cache@v1

21− with:

22− path: ~/.stack

23− key: ${{ runner.os }}-${{ matrix.resolver }}-${{ hashFiles('stack.yaml') }}

24− restore-keys: |

25− ${{ runner.os }}-${{ matrix.resolver }}-

26−

27− - name: Build and run tests

28− shell: bash

29− run: |

30− set -ex

31− stack upgrade || curl -sSL https://get.haskellstack.org/ | sh -s - -f

32− stack test --fast --no-terminal --resolver=${{ matrix.resolver }}

.gitignore−2

@@ -1,4 +1,2 @@

1dist

2*.swp

3−.stack-work

4−/tarballs/

ChangeLog.md−46

@@ -1,49 +1,3 @@

1−# ChangeLog for file-embed

2−

3−## 0.0.15.0

4−

5−* Add `makeRelativeToLocationPredicate`

6−

7−## 0.0.14.0

8−

9−* Add `embedFileIfExists`

10−

11−## 0.0.13.0

12−

13−* Ensure that directory listings are returned in sorted order for reproducibility [yesodweb/yesod#1684](https://github.com/yesodweb/yesod/issues/1684)

14−

15−## 0.0.12.0

16−

17−* Use the `Bytes` literal on newer GHCs to reduce memory usage during compilation [#36](https://github.com/snoyberg/file-embed/pull/36)

18−

19−## 0.0.11.2

20−

21−* Haddock markup fix

22−

23−## 0.0.11.1

24−

25−* Support GHC 8.10

26−

27−## 0.0.11

28−

29−* embedDirListing [#26](https://github.com/snoyberg/file-embed/pull/26)

30−

31−## 0.0.10.1

32−

33−* Minor doc improvements

34−

35−## 0.0.10

36−

37−* `makeRelativeToProject`

38−

39−## 0.0.9

40−

41−* embedStringFile [#14](https://github.com/snoyberg/file-embed/pull/14)

42−

43−## 0.0.8.2

44−

45−* Improve inject documentation [#11](https://github.com/snoyberg/file-embed/issues/11)

46−

47## 0.0.8.1

1## 0.0.8.1

49Minor cleanup

3Minor cleanup

Data/FileEmbed.hs+14−202

@@ -3,7 +3,7 @@

3{-# LANGUAGE OverloadedStrings #-}

4-- | This module uses template Haskell. Following is a simplified explanation of usage for those unfamiliar with calling Template Haskell functions.

5--

6−-- The function @embedFile@ in this modules embeds a file into the executable

6+-- The function @embedFile@ in this modules embeds a file into the exceutable

7-- that you can use it at runtime. A file is represented as a @ByteString@.

8-- However, as you can see below, the type signature indicates a value of type

9-- @Q Exp@ will be returned. In order to convert this into a @ByteString@, you

@@ -19,16 +19,10 @@

19module Data.FileEmbed

20 ( -- * Embed at compile time

21 embedFile

22− , embedFileIfExists

23 , embedOneFileOf

22 , embedOneFileOf

24 , embedDir

23 , embedDir

25− , embedDirListing

26 , getDir

24 , getDir

27− -- * Embed as a IsString

28− , embedStringFile

29− , embedOneStringFileOf

30 -- * Inject into an executable

25 -- * Inject into an executable

31− -- $inject

32#if MIN_VERSION_template_haskell(2,5,0)

26#if MIN_VERSION_template_haskell(2,5,0)

33 , dummySpace

27 , dummySpace

34 , dummySpaceWith

28 , dummySpaceWith

@@ -37,45 +31,35 @@ module Data.FileEmbed

37 , injectFile

31 , injectFile

38 , injectWith

32 , injectWith

39 , injectFileWith

33 , injectFileWith

40− -- * Relative path manipulation

41− , makeRelativeToProject

42− , makeRelativeToLocationPredicate

43 -- * Internal

34 -- * Internal

44 , stringToBs

35 , stringToBs

45 , bsToExp

36 , bsToExp

46− , strToExp

47 ) where

37 ) where

49import Language.Haskell.TH.Syntax

39import Language.Haskell.TH.Syntax

50 ( Exp (AppE, ListE, LitE, TupE, SigE, VarE)

40 ( Exp (AppE, ListE, LitE, TupE, SigE, VarE)

51− , Lit (..)

41+#if MIN_VERSION_template_haskell(2,5,0)

42+ , Lit (StringL, StringPrimL, IntegerL)

43+#else

44+ , Lit (StringL, IntegerL)

45+#endif

52 , Q

46 , Q

53 , runIO

47 , runIO

54− , qLocation, loc_filename

55#if MIN_VERSION_template_haskell(2,7,0)

48#if MIN_VERSION_template_haskell(2,7,0)

56 , Quasi(qAddDependentFile)

49 , Quasi(qAddDependentFile)

57#endif

50#endif

58 )

51 )

59−#if MIN_VERSION_template_haskell(2,16,0)

60−import Language.Haskell.TH ( mkBytes, bytesPrimL )

61−import qualified Data.ByteString.Internal as B

62−#endif

63import System.Directory (doesDirectoryExist, doesFileExist,

52import System.Directory (doesDirectoryExist, doesFileExist,

64− getDirectoryContents, canonicalizePath)

53+ getDirectoryContents)

65−import Control.Exception (throw, tryJust, ErrorCall(..))

54+import Control.Exception (throw, ErrorCall(..))

66−import Control.Monad (filterM, guard)

55+import Control.Monad (filterM)

67import qualified Data.ByteString as B

56import qualified Data.ByteString as B

68import qualified Data.ByteString.Char8 as B8

57import qualified Data.ByteString.Char8 as B8

69import Control.Arrow ((&&&), second)

58import Control.Arrow ((&&&), second)

70import Control.Applicative ((<$>))

59import Control.Applicative ((<$>))

71import Data.ByteString.Unsafe (unsafePackAddressLen)

60import Data.ByteString.Unsafe (unsafePackAddressLen)

72−import System.IO.Error (isDoesNotExistError)

73import System.IO.Unsafe (unsafePerformIO)

61import System.IO.Unsafe (unsafePerformIO)

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

62+import System.FilePath ((</>))

75−import Data.String (fromString)

76−import Prelude as P

77−import Data.List (sortBy)

78−import Data.Ord (comparing)

80-- | Embed a single file in your source code.

64-- | Embed a single file in your source code.

81--

65--

@@ -90,40 +74,13 @@ embedFile fp =

90#endif

74#endif

91 (runIO $ B.readFile fp) >>= bsToExp

75 (runIO $ B.readFile fp) >>= bsToExp

93−-- | Maybe embed a single file in your source code depending on whether or not file exists.

94−--

95−-- Warning: When a build is compiled with the file missing, a recompile when the file exists might not trigger an embed of the file.

96−-- You might try to fix this by doing a clean build.

97−--

98−-- > import qualified Data.ByteString

99−-- >

100−-- > maybeMyFile :: Maybe Data.ByteString.ByteString

101−-- > maybeMyFile = $(embedFileIfExists "dirName/fileName")

102−--

103−-- @since 0.0.14.0

104−embedFileIfExists :: FilePath -> Q Exp

105−embedFileIfExists fp = do

106− mbs <- runIO maybeFile

107− case mbs of

108− Nothing -> [| Nothing |]

109− Just bs -> do

110−#if MIN_VERSION_template_haskell(2,7,0)

111− qAddDependentFile fp

112−#endif

113− [| Just $(bsToExp bs) |]

114− where

115− maybeFile :: IO (Maybe B.ByteString)

116− maybeFile =

117− either (const Nothing) Just <$>

118− tryJust (guard . isDoesNotExistError) (B.readFile fp)

119−

120-- | Embed a single existing file in your source code

77-- | Embed a single existing file in your source code

121-- out of list a list of paths supplied.

78-- out of list a list of paths supplied.

122--

79--

123-- > import qualified Data.ByteString

80-- > import qualified Data.ByteString

124-- >

81-- >

125-- > myFile :: Data.ByteString.ByteString

82-- > myFile :: Data.ByteString.ByteString

126−-- > myFile = $(embedOneFileOf [ "dirName/fileName", "src/dirName/fileName" ])

83+-- > myFile = $(embedFile' [ "dirName/fileName", "src/dirName/fileName" ])

127embedOneFileOf :: [FilePath] -> Q Exp

84embedOneFileOf :: [FilePath] -> Q Exp

128embedOneFileOf ps =

85embedOneFileOf ps =

129 (runIO $ readExistingFile ps) >>= \ ( path, content ) -> do

86 (runIO $ readExistingFile ps) >>= \ ( path, content ) -> do

@@ -151,18 +108,6 @@ embedDir fp = do

151 e <- ListE <$> ((runIO $ fileList fp) >>= mapM (pairToExp fp))

108 e <- ListE <$> ((runIO $ fileList fp) >>= mapM (pairToExp fp))

152 return $ SigE e typ

109 return $ SigE e typ

153

110

154−-- | Embed a directory listing recursively in your source code.

155−--

156−-- > myFiles :: [FilePath]

157−-- > myFiles = $(embedDirListing "dirName")

158−--

159−-- @since 0.0.11

160−embedDirListing :: FilePath -> Q Exp

161−embedDirListing fp = do

162− typ <- [t| [FilePath] |]

163− e <- ListE <$> ((runIO $ fmap fst <$> fileList fp) >>= mapM strToExp)

164− return $ SigE e typ

165−

166-- | Get a directory tree in the IO monad.

111-- | Get a directory tree in the IO monad.

167--

112--

168-- This is the workhorse of 'embedDir'

113-- This is the workhorse of 'embedDir'

@@ -175,11 +120,7 @@ pairToExp _root (path, bs) = do

175 qAddDependentFile $ _root ++ '/' : path

120 qAddDependentFile $ _root ++ '/' : path

176#endif

121#endif

177 exp' <- bsToExp bs

122 exp' <- bsToExp bs

178− return $! TupE

179−#if MIN_VERSION_template_haskell(2,16,0)

180− $ map Just

181−#endif

182− [LitE $ StringL path, exp']

123+ return $! TupE [LitE $ StringL path, exp']

183

124

184bsToExp :: B.ByteString -> Q Exp

125bsToExp :: B.ByteString -> Q Exp

185#if MIN_VERSION_template_haskell(2, 5, 0)

126#if MIN_VERSION_template_haskell(2, 5, 0)

@@ -187,11 +128,7 @@ bsToExp bs =

187 return $ VarE 'unsafePerformIO

128 return $ VarE 'unsafePerformIO

188 `AppE` (VarE 'unsafePackAddressLen

129 `AppE` (VarE 'unsafePackAddressLen

189 `AppE` LitE (IntegerL $ fromIntegral $ B8.length bs)

130 `AppE` LitE (IntegerL $ fromIntegral $ B8.length bs)

190−#if MIN_VERSION_template_haskell(2, 16, 0)

131+#if MIN_VERSION_template_haskell(2, 8, 0)

191− `AppE` LitE (bytesPrimL (

192− let B.PS ptr off sz = bs

193− in mkBytes ptr (fromIntegral off) (fromIntegral sz))))

194−#elif MIN_VERSION_template_haskell(2, 8, 0)

195 `AppE` LitE (StringPrimL $ B.unpack bs))

132 `AppE` LitE (StringPrimL $ B.unpack bs))

196#else

133#else

197 `AppE` LitE (StringPrimL $ B8.unpack bs))

134 `AppE` LitE (StringPrimL $ B8.unpack bs))

@@ -206,51 +143,6 @@ bsToExp bs = do

206stringToBs :: String -> B.ByteString

143stringToBs :: String -> B.ByteString

207stringToBs = B8.pack

144stringToBs = B8.pack

208

145

209−-- | Embed a single file in your source code.

210−--

211−-- > import Data.String

212−-- >

213−-- > myFile :: IsString a => a

214−-- > myFile = $(embedStringFile "dirName/fileName")

215−--

216−-- Since 0.0.9

217−embedStringFile :: FilePath -> Q Exp

218−embedStringFile fp =

219−#if MIN_VERSION_template_haskell(2,7,0)

220− qAddDependentFile fp >>

221−#endif

222− (runIO $ P.readFile fp) >>= strToExp

223−

224−-- | Embed a single existing string file in your source code

225−-- out of list a list of paths supplied.

226−--

227−-- Since 0.0.9

228−embedOneStringFileOf :: [FilePath] -> Q Exp

229−embedOneStringFileOf ps =

230− (runIO $ readExistingFile ps) >>= \ ( path, content ) -> do

231−#if MIN_VERSION_template_haskell(2,7,0)

232− qAddDependentFile path

233−#endif

234− strToExp content

235− where

236− readExistingFile :: [FilePath] -> IO ( FilePath, String )

237− readExistingFile xs = do

238− ys <- filterM doesFileExist xs

239− case ys of

240− (p:_) -> P.readFile p >>= \ c -> return ( p, c )

241− _ -> throw $ ErrorCall "Cannot find file to embed as resource"

242−

243−strToExp :: String -> Q Exp

244−#if MIN_VERSION_template_haskell(2, 5, 0)

245−strToExp s =

246− return $ VarE 'fromString

247− `AppE` LitE (StringL s)

248−#else

249−strToExp s = do

250− helper <- [| fromString |]

251− return $! AppE helper $! LitE $! StringL s

252−#endif

253−

254notHidden :: FilePath -> Bool

146notHidden :: FilePath -> Bool

255notHidden ('.':_) = False

147notHidden ('.':_) = False

256notHidden _ = True

148notHidden _ = True

@@ -266,7 +158,7 @@ fileList' realTop top = do

266 mapM (liftPair2 . second B.readFile)

158 mapM (liftPair2 . second B.readFile)

267 dirs <- filterM (doesDirectoryExist . snd) all' >>=

159 dirs <- filterM (doesDirectoryExist . snd) all' >>=

268 mapM (fileList' realTop . fst)

160 mapM (fileList' realTop . fst)

269− return $ sortBy (comparing fst) $ concat $ files : dirs

161+ return $ concat $ files : dirs

270

162

271liftPair2 :: Monad m => (a, m b) -> m (a, b)

163liftPair2 :: Monad m => (a, m b) -> m (a, b)

272liftPair2 (a, b) = b >>= \b' -> return (a, b')

164liftPair2 (a, b) = b >>= \b' -> return (a, b')

@@ -290,8 +182,6 @@ padSize i =

290 in replicate (sizeLen - length s) '0' ++ s

182 in replicate (sizeLen - length s) '0' ++ s

291

183

292#if MIN_VERSION_template_haskell(2,5,0)

184#if MIN_VERSION_template_haskell(2,5,0)

293−-- | Allocate the given number of bytes in the generate executable. That space

294−-- can be filled up with the 'inject' and 'injectFile' functions.

295dummySpace :: Int -> Q Exp

185dummySpace :: Int -> Q Exp

296dummySpace = dummySpaceWith "MS"

186dummySpace = dummySpaceWith "MS"

297

187

@@ -316,9 +206,6 @@ dummySpaceWith postfix space = do

316 [| getInner (B.drop magicLen (unsafePerformIO (unsafePackAddressLen len $(return chars)))) |]

206 [| getInner (B.drop magicLen (unsafePerformIO (unsafePackAddressLen len $(return chars)))) |]

317#endif

207#endif

318

208

319−-- | Inject some raw data inside a @ByteString@ containing empty, dummy space

320−-- (allocated with @dummySpace@). Typically, the original @ByteString@ is an

321−-- executable read from the filesystem.

322inject :: B.ByteString -- ^ bs to inject

209inject :: B.ByteString -- ^ bs to inject

323 -> B.ByteString -- ^ original BS containing dummy

210 -> B.ByteString -- ^ original BS containing dummy

324 -> Maybe B.ByteString -- ^ new BS, or Nothing if there is insufficient dummy space

211 -> Maybe B.ByteString -- ^ new BS, or Nothing if there is insufficient dummy space

@@ -345,9 +232,6 @@ injectWith postfix toInj orig =

345 [] -> error $ "Data.FileEmbed (inject): Your dummy space has been corrupted. Size is: " ++ show sizeBS

232 [] -> error $ "Data.FileEmbed (inject): Your dummy space has been corrupted. Size is: " ++ show sizeBS

346 after = B.drop size rest'

233 after = B.drop size rest'

347

234

348−-- | Same as 'inject', but instead of performing the injecting in memory, read

349−-- the contents from the filesystem and write back to a different file on the

350−-- filesystem.

351injectFile :: B.ByteString -- ^ bs to inject

235injectFile :: B.ByteString -- ^ bs to inject

352 -> FilePath -- ^ template file

236 -> FilePath -- ^ template file

353 -> FilePath -- ^ output file

237 -> FilePath -- ^ output file

@@ -367,75 +251,3 @@ injectFileWith postfix inj srcFP dstFP = do

367 case injectWith postfix inj src of

251 case injectWith postfix inj src of

368 Nothing -> error "Insufficient dummy space"

252 Nothing -> error "Insufficient dummy space"

369 Just dst -> B.writeFile dstFP dst

253 Just dst -> B.writeFile dstFP dst

370−

371−{- $inject

372−

373−The inject system allows arbitrary content to be embedded inside a Haskell

374−executable, post compilation. Typically, file-embed allows you to read some

375−contents from the file system at compile time and embed them inside your

376−executable. Consider a case, instead, where you would want to embed these

377−contents after compilation. Two real-world examples are:

378−

379−* You would like to embed a hash of the executable itself, for sanity checking in a network protocol. (Obviously the hash will change after you embed the hash.)

380−

381−* You want to create a self-contained web server that has a set of content, but will need to update the content on machines that do not have access to GHC.

382−

383−The typical workflow use:

384−

385−* Use 'dummySpace' or 'dummySpaceWith' to create some empty space in your executable

386−

387−* Use 'injectFile' or 'injectFileWith' from a separate utility to modify that executable to have the updated content.

388−

389−The reason for the @With@-variant of the functions is for cases where you wish

390−to inject multiple different kinds of content, and therefore need control over

391−the magic key. If you know for certain that there will only be one dummy space

392−available, you can use the non-@With@ variants.

393−

394−-}

395−

396−-- | Take a relative file path and attach it to the root of the current

397−-- project.

398−--

399−-- The idea here is that, when building with Stack, the build will always be

400−-- executed with a current working directory of the root of the project (where

401−-- your .cabal file is located). However, if you load up multiple projects with

402−-- @stack ghci@, the working directory may be something else entirely.

403−--

404−-- This function looks at the source location of the Haskell file calling it,

405−-- finds the first parent directory with a .cabal file, and uses that as the

406−-- root directory for fixing the relative path.

407−--

408−-- @$(makeRelativeToProject "data/foo.txt" >>= embedFile)@

409−--

410−-- @since 0.0.10

411−makeRelativeToProject :: FilePath -> Q FilePath

412−makeRelativeToProject = makeRelativeToLocationPredicate $ (==) ".cabal" . takeExtension

413−

414−-- | Take a predicate to infer the project root and a relative file path, the given file path is then attached to the inferred project root

415−--

416−-- This function looks at the source location of the Haskell file calling it,

417−-- finds the first parent directory with a file matching the given predicate, and uses that as the

418−-- root directory for fixing the relative path.

419−--

420−-- @$(makeRelativeToLocationPredicate ((==) ".cabal" . takeExtension) "data/foo.txt" >>= embedFile)@

421−--

422−-- @since 0.0.15.0

423−makeRelativeToLocationPredicate :: (FilePath -> Bool) -> FilePath -> Q FilePath

424−makeRelativeToLocationPredicate isTargetFile rel = do

425− loc <- qLocation

426− runIO $ do

427− srcFP <- canonicalizePath $ loc_filename loc

428− mdir <- findProjectDir srcFP

429− case mdir of

430− Nothing -> error $ "Could not find .cabal file for path: " ++ srcFP

431− Just dir -> return $ dir </> rel

432− where

433− findProjectDir x = do

434− let dir = takeDirectory x

435− if dir == x

436− then return Nothing

437− else do

438− contents <- getDirectoryContents dir

439− if any isTargetFile contents

440− then return (Just dir)

441− else findProjectDir dir

README.md−2

@@ -1,6 +1,4 @@

1## file-embed

3−![Tests](https://github.com/snoyberg/file-embed/workflows/Tests/badge.svg)

4−

5Use Template Haskell to read a file or all the files in a directory, and turn

3Use Template Haskell to read a file or all the files in a directory, and turn

6them into (path, bytestring) pairs embedded in your haskell code.

4them into (path, bytestring) pairs embedded in your haskell code.

file-embed.cabal+6−8

@@ -1,16 +1,16 @@

1name: file-embed

2−version: 0.0.15.0

2+version: 0.0.8

3−license: BSD2

3+license: BSD3

4license-file: LICENSE

5author: Michael Snoyman <michael@snoyman.com>

6maintainer: Michael Snoyman <michael@snoyman.com>

7synopsis: Use Template Haskell to embed file contents directly.

8description: Use Template Haskell to read a file or all the files in a

9 directory, and turn them into (path, bytestring) pairs

10− embedded in your Haskell code.

10+ embedded in your haskell code.

11category: Data

12stability: Stable

13−cabal-version: >= 1.10

13+cabal-version: >= 1.8

14build-type: Simple

15homepage: https://github.com/snoyberg/file-embed

16extra-source-files: test/main.hs, test/sample/foo, test/sample/bar/baz,

@@ -18,8 +18,7 @@ extra-source-files: test/main.hs, test/sample/foo, test/sample/bar/baz,

18 README.md

20library

21− default-language: Haskell2010

22− build-depends: base >= 4.9.1 && < 5

21+ build-depends: base >= 4 && < 5

23 , bytestring >= 0.9.1.4

22 , bytestring >= 0.9.1.4

24 , directory >= 1.0.0.3

23 , directory >= 1.0.0.3

25 , template-haskell

24 , template-haskell

@@ -28,13 +27,12 @@ library

28 ghc-options: -Wall

27 ghc-options: -Wall

30test-suite test

29test-suite test

31− default-language: Haskell2010

32 type: exitcode-stdio-1.0

30 type: exitcode-stdio-1.0

33 main-is: main.hs

31 main-is: main.hs

34 hs-source-dirs: test

32 hs-source-dirs: test

35 build-depends: base

33 build-depends: base

36− , bytestring

37 , file-embed

34 , file-embed

35+ , HUnit

38 , filepath

36 , filepath

40source-repository head

38source-repository head

stack.yamldeleted−1

@@ -1 +0,0 @@

1−resolver: lts-14.17

test/main.hs+3−17

@@ -1,28 +1,14 @@

1{-# LANGUAGE TemplateHaskell #-}

2{-# LANGUAGE OverloadedStrings #-}

4−import Control.Monad (unless)

5−import qualified Data.ByteString as B (ByteString, filter)

6import Data.FileEmbed

4import Data.FileEmbed

5+import Test.HUnit ((@?=))

7import System.FilePath ((</>))

6import System.FilePath ((</>))

9−infix 1 @?=

10−

11−(@?=) :: (Eq a, Show a) => a -> a -> IO ()

12−actual @?= expected = unless (actual == expected) (error $ "expected: " ++ show expected ++ "\n but got: " ++ show actual)

13−

14main :: IO ()

8main :: IO ()

15main = do

9main = do

16 let received = $(embedDir "test/sample")

10 let received = $(embedDir "test/sample")

17 received @?=

11 received @?=

12+ [ ("foo", "foo\r\n")

18− [ ("bar" </> "baz", "baz\r\n")

13+ , ("bar" </> "baz", "baz\r\n")

19− , ("foo", "foo\r\n")

20 ]

14 ]

21− let str = $(embedStringFile "test/sample/foo") :: String

22− filter (/= '\r') str @?= "foo\n"

23−

24− let mbs = $(embedFileIfExists "test/sample/foo")

25− fmap (B.filter (/= fromIntegral (fromEnum '\r'))) mbs @?= Just "foo\n"

26−

27− let mbs2 = $(embedFileIfExists "test/sample/foo2") :: Maybe B.ByteString

28− mbs2 @?= Nothing