f56ce13..master · obelisk

ChangeLog.md−9

@@ -2,15 +2,6 @@

2

3This project's release branch is `master`. This log is written from the perspective of the release branch: when changes hit `master`, they are considered released.

4

5−## Unreleased

6−

7−* Use TemplateHaskell to determine asset file paths

8− * Migration: All uses of `static @"some/path"` become `$(static "some/path")`. Instead of requiring `TypeApplications` and `DataKinds`, modules calling `static` must now enable `TemplateHaskell`.

9− * Deprecation: Deprecate static asset modules generated via 'obelisk-asset-manifest-generate' in favor of modules generated via 'obelisk-asset-th-generate'. The new executable takes the same arguments as the old and should be a drop-in replacement. To preserve the old behavior, set `__deprecated.useObeliskAssetManifestGenerate = true;` in your obelisk project configuration.

10− * Feature: Files added to the static directory while `ob run` is active no longer require `ob run` to be restarted

11−* Feature: When `staticFiles` is a derivation, as opposed to a regular directory, produce a symlink to the result of that derivation at `static.out` and have `ob run` serve static assets from that symlink. This makes is possible for the static asset derivation to be rebuilt and the new results served without restarting `ob run`.

12−* Feature: Rebuild static asset derivations while `ob run` is active as long as the change to the derivation is within the project folder. `ob run` now displays a message ("Static assets rebuilt and symlinked to static.out") whenever static assets have been rebuilt and the new static assets are being served.

13−

14## v0.9.1.0

5## v0.9.1.0

15

6

16* [#801](https://github.com/obsidiansystems/obelisk/pull/801): Remove errors and warning for local packages without a library component

7* [#801](https://github.com/obsidiansystems/obelisk/pull/801): Remove errors and warning for local packages without a library component

default.nix+4−10

@@ -65,7 +65,7 @@ in rec {

65 '';

66 nullIfAbsent = p: if lib.pathExists p then p else null;

67 #TODO: Avoid copying files within the nix store. Right now, obelisk-asset-manifest-generate copies files into a big blob so that the android/ios static assets can be imported from there; instead, we should get everything lined up right before turning it into an APK, so that copies, if necessary, only exist temporarily.

68− processAssets = { src, packageName ? "obelisk-generated-static", moduleName ? "Obelisk.Generated.Static", exe ? "obelisk-asset-th-generate" }: pkgs.runCommand "asset-manifest" {

68+ processAssets = { src, packageName ? "obelisk-generated-static", moduleName ? "Obelisk.Generated.Static" }: pkgs.runCommand "asset-manifest" {

69 inherit src;

70 outputs = [ "out" "haskellManifest" "symlinked" ];

71 nativeBuildInputs = [ ghcObelisk.obelisk-asset-manifest ];

@@ -73,7 +73,7 @@ in rec {

73 set -euo pipefail

74 touch "$out"

75 mkdir -p "$symlinked"

76− ${exe} "$src" "$haskellManifest" ${packageName} ${moduleName} "$symlinked"

76+ obelisk-asset-manifest-generate "$src" "$haskellManifest" ${packageName} ${moduleName} "$symlinked"

77 '';

78

79 compressedJs = frontend: optimizationLevel: pkgs.runCommand "compressedJs" {} ''

@@ -237,14 +237,13 @@ in rec {

237 , withHoogle ? false # Setting this to `true` makes shell reloading far slower

238 , __closureCompilerOptimizationLevel ? "ADVANCED" # Set this to `null` to skip the closure-compiler step

239 , __withGhcide ? false

240− , __deprecated ? {}

241 }:

240 }:

242 let

241 let

243 allConfig = nixpkgs.lib.makeExtensible (self: {

242 allConfig = nixpkgs.lib.makeExtensible (self: {

244 base = base';

243 base = base';

245 inherit args;

244 inherit args;

246 userSettings = {

245 userSettings = {

247− inherit android ios packages overrides tools shellToolOverrides withHoogle __closureCompilerOptimizationLevel __withGhcide __deprecated;

246+ inherit android ios packages overrides tools shellToolOverrides withHoogle __closureCompilerOptimizationLevel __withGhcide;

248 staticFiles = if staticFiles == null then self.base + /static else staticFiles;

247 staticFiles = if staticFiles == null then self.base + /static else staticFiles;

249 };

248 };

250 frontendName = "frontend";

249 frontendName = "frontend";

@@ -252,12 +251,7 @@ in rec {

252 commonName = "common";

251 commonName = "common";

253 staticName = "obelisk-generated-static";

252 staticName = "obelisk-generated-static";

254 staticFilesImpure = let fs = self.userSettings.staticFiles; in if lib.isDerivation fs then fs else toString fs;

253 staticFilesImpure = let fs = self.userSettings.staticFiles; in if lib.isDerivation fs then fs else toString fs;

255− processedStatic = processAssets {

256− src = self.userSettings.staticFiles;

254+ processedStatic = processAssets { src = self.userSettings.staticFiles; };

257− exe = if lib.attrByPath ["userSettings" "__deprecated" "useObeliskAssetManifestGenerate"] false self

258− then builtins.trace "obelisk-asset-manifest-generate is deprecated. Use obelisk-asset-th-generate instead." "obelisk-asset-manifest-generate"

259− else "obelisk-asset-th-generate";

260− };

261 # The packages whose names and roles are defined by this package

255 # The packages whose names and roles are defined by this package

262 predefinedPackages = lib.filterAttrs (_: x: x != null) {

256 predefinedPackages = lib.filterAttrs (_: x: x != null) {

263 ${self.frontendName} = nullIfAbsent (self.base + "/frontend");

257 ${self.frontendName} = nullIfAbsent (self.base + "/frontend");

lib/asset/README.md+2−2

@@ -5,7 +5,7 @@

5

6**Efficiently served, aggressively cached static web resources.**

7

8−The `assets.nix` file contains nix expressions that are a mutually recursive set of attributes used to create static asset directories with hashable file encodings. This file should be incorporated within your project's `default.nix` file.

8+The `assets.nix` file contains nix expressions that are a mutually recursive set of attributes used to create static asset directories with hashable file encodings. This file should be incorporated within your project's `default.nix` file. (See `example/default.nix`, line 2)

9

10```nix

11{ assets ? import ./../assets.nix { inherit nixpkgs; } }:

@@ -19,7 +19,7 @@ In this example, `mkAssets` is used on a directory that has a `.png` file inside

19myAssets = assets.mkAssets ./static;

20```

21

22−Once you have successfully incorporated `assets.nix` into your project's nix file(s), use `nix-build` to generate a symlink of your `mkAssets` expression. The following command will generate an immutable symlink that holds hashed static assets.

22+Once you have successfully incorporated `assets.nix` into your project's nix file(s), use `nix-build` to generate a symlink of your `mkAssets` expression. The following command from `example/run-example` (line 3) will generate an immutable symlink that holds hashed static assets.

23

24```bash

25nix-build -o static.assets -A myAssets

lib/asset/manifest/obelisk-asset-manifest.cabal+1−11

@@ -27,7 +27,6 @@ library

27 , unix-compat

28 , vector

29 exposed-modules:

30− Obelisk.Asset.Cabal

31 Obelisk.Asset.Gather

30 Obelisk.Asset.Gather

32 Obelisk.Asset.Promoted

31 Obelisk.Asset.Promoted

33 Obelisk.Asset.Symlink

32 Obelisk.Asset.Symlink

@@ -36,7 +35,7 @@ library

36 other-extensions: TemplateHaskell

35 other-extensions: TemplateHaskell

37 ghc-options:

36 ghc-options:

38 -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O2

37 -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O2

39− -fno-warn-unused-do-bind -funbox-strict-fields -fprof-auto-calls

38+ -fno-warn-unused-do-bind -funbox-strict-fields -fprof-auto-calls

40

39

41executable obelisk-asset-manifest-generate

40executable obelisk-asset-manifest-generate

42 hs-source-dirs: src-bin

41 hs-source-dirs: src-bin

@@ -45,12 +44,3 @@ executable obelisk-asset-manifest-generate

45 base

44 base

46 , obelisk-asset-manifest

45 , obelisk-asset-manifest

47 , text

46 , text

48−

49−executable obelisk-asset-th-generate

50− hs-source-dirs: src-bin

51− main-is: static-th.hs

52− build-depends:

53− base

54− , obelisk-asset-manifest

55− , filepath

56− , text

lib/asset/manifest/src-bin/static-th.hsdeleted−41

@@ -1,41 +0,0 @@

1−import qualified Data.Text as T

2−import Obelisk.Asset.Cabal

3−import Obelisk.Asset.Gather

4−import Obelisk.Asset.Symlink

5−import System.Environment

6−import System.FilePath

7−

8−main :: IO ()

9−main = do

10− --TODO: Usage

11− [root, haskellTarget, packageName, moduleName, fileTarget] <- getArgs

12− paths <- gatherHashedPaths root

13− writeCabalProject haskellTarget $ SimplePkg

14− { _simplePkg_name = T.pack packageName

15− , _simplePkg_moduleName = T.pack moduleName

16− , _simplePkg_dependencies = map T.pack

17− [ "base"

18− , "obelisk-asset-manifest"

19− , "template-haskell"

20− ]

21− , _simplePkg_moduleContents = T.pack $ unlines

22− [ "{-# Language CPP #-}"

23− , "{-|"

24− , " Description:"

25− , " Automatically generated module that provides the 'static' TH function"

26− , " to generate paths to static assets."

27− , "-}"

28− , "module " <> moduleName <> " ( static ) where"

29− , ""

30− , "import Obelisk.Asset.TH"

31− , "import Language.Haskell.TH"

32− , ""

33− , "static :: FilePath -> Q Exp"

34− , "#ifdef OBELISK_ASSET_PASSTHRU"

35− , "static = staticAssetRaw"

36− , "#else"

37− , "static = staticAssetHashed " <> show root

38− , "#endif"

39− ]

40− }

41− copyAndSymlink paths root fileTarget

lib/asset/manifest/src/Obelisk/Asset/Cabal.hsdeleted−42

@@ -1,42 +0,0 @@

1−{-# Language OverloadedStrings #-}

2−module Obelisk.Asset.Cabal where

3−

4−import qualified Data.List as L

5−import Data.Text (Text)

6−import qualified Data.Text as T

7−import qualified Data.Text.IO as T

8−import System.Directory

9−import System.FilePath

10−

11−-- | A generated single-module package

12−data SimplePkg = SimplePkg

13− { _simplePkg_name :: Text

14− , _simplePkg_moduleName :: Text

15− , _simplePkg_moduleContents :: Text

16− , _simplePkg_dependencies :: [Text]

17− }

18−

19−cabalFile :: SimplePkg -> Text

20−cabalFile (SimplePkg packageName moduleName _ deps) = T.unlines

21− [ "name: " <> packageName

22− , "version: 0"

23− , "cabal-version: >= 1.2"

24− , "build-type: Simple"

25− , ""

26− , "library"

27− , " hs-source-dirs: src"

28− , " build-depends:"

29− , " " <> T.intercalate ", " deps

30− , " exposed-modules: " <> moduleName

31− ]

32−

33−writeCabalProject :: FilePath -> SimplePkg -> IO ()

34−writeCabalProject target pkg = do

35− createDirectoryIfMissing True target

36− T.writeFile (target </> T.unpack (_simplePkg_name pkg) <.> "cabal") $ cabalFile pkg

37− let moduleName = _simplePkg_moduleName pkg

38− (modName', moduleDirPath) = case L.uncons (reverse $ T.splitOn "." moduleName) of

39− Nothing -> error $ "writeStaticProject: invalid module name " <> T.unpack moduleName

40− Just (name, parents) -> (name, target </> "src" </> T.unpack (T.intercalate "/" $ reverse parents))

41− createDirectoryIfMissing True moduleDirPath

42− T.writeFile (moduleDirPath </> T.unpack modName' <.> "hs") $ _simplePkg_moduleContents pkg

lib/asset/manifest/src/Obelisk/Asset/Gather.hs+13−13

@@ -6,21 +6,21 @@ module Obelisk.Asset.Gather

6 , toHashedPath

7 ) where

8

9−import Control.DeepSeq (force)

9+import Control.DeepSeq

10import Control.Monad (forM)

11−import Data.Bits (shift, (.|.), (.&.))

11+import Data.Bits

12−import qualified Data.ByteString.Lazy as LBS (readFile, toStrict, ByteString, length, index)

12+import qualified Data.ByteString.Lazy as LBS

13−import qualified Data.ByteString.Lazy.Builder as LBS (toLazyByteString, word8)

13+import qualified Data.ByteString.Lazy.Builder as LBS

14−import Data.Char (ord)

14+import Data.Char

15−import Data.Digest.Pure.SHA (bytestringDigest, sha256)

15+import Data.Digest.Pure.SHA

16import Data.Map (Map)

17−import qualified Data.Map as Map (singleton)

17+import qualified Data.Map as Map

18−import qualified Data.Text as T (unpack)

18+import qualified Data.Text as T

19−import Data.Text.Encoding (decodeUtf8)

19+import Data.Text.Encoding

20−import qualified Data.Vector.Unboxed as UV ((!), fromList)

20+import qualified Data.Vector.Unboxed as UV

21−import Data.Word (Word8)

21+import Data.Word

22−import System.FilePath.Posix ((</>), splitFileName, normalise)

22+import System.FilePath.Posix

23−import System.Directory (listDirectory, doesFileExist)

23+import System.Directory

24

25-- | Given a path, recursively explore it, creating hashed paths for all files found

26gatherHashedPaths

lib/asset/manifest/src/Obelisk/Asset/Promoted.hs+27−8

@@ -10,6 +10,7 @@ module Obelisk.Asset.Promoted

10import Obelisk.Asset.Gather

11

12import Data.Foldable

13+import qualified Data.List as L

13import Language.Haskell.TH (runQ, pprint)

14import Language.Haskell.TH (runQ, pprint)

14import Language.Haskell.TH.Syntax hiding (lift)

15import Language.Haskell.TH.Syntax hiding (lift)

15import GHC.TypeLits

16import GHC.TypeLits

@@ -17,11 +18,12 @@ import Data.Sequence (Seq)

17import qualified Data.Sequence as Seq

18import qualified Data.Sequence as Seq

18import Control.Monad.Trans.Writer

19import Control.Monad.Trans.Writer

19import System.FilePath

20import System.FilePath

21+import System.Directory

20import Data.Text (Text)

22import Data.Text (Text)

21import qualified Data.Text as T

23import qualified Data.Text as T

24+import qualified Data.Text.IO as T

22import Data.Map (Map)

25import Data.Map (Map)

23import qualified Data.Map as Map

26import qualified Data.Map as Map

24−import Obelisk.Asset.Cabal (writeCabalProject, SimplePkg(..))

25

27

26data StaticConfig = StaticConfig

28data StaticConfig = StaticConfig

27 { _staticConfig_packageName :: Text --TODO: Better type

29 { _staticConfig_packageName :: Text --TODO: Better type

@@ -30,14 +32,31 @@ data StaticConfig = StaticConfig

30

32

31writeStaticProject :: Map FilePath FilePath -> FilePath -> StaticConfig -> IO ()

33writeStaticProject :: Map FilePath FilePath -> FilePath -> StaticConfig -> IO ()

32writeStaticProject paths target cfg = do

34writeStaticProject paths target cfg = do

35+ createDirectoryIfMissing True target

36+ T.writeFile (target </> T.unpack (_staticConfig_packageName cfg) <.> "cabal") $ staticCabalFile cfg

33 let modName = _staticConfig_moduleName cfg

37 let modName = _staticConfig_moduleName cfg

38+ (modName', moduleDirPath) = case L.uncons (reverse $ T.splitOn "." modName) of

39+ Nothing -> error $ "writeStaticProject: invalid module name " <> T.unpack modName

40+ Just (name, parents) -> (name, target </> "src" </> T.unpack (T.intercalate "/" $ reverse parents))

41+ createDirectoryIfMissing True moduleDirPath

34 modContents <- staticModuleFile modName paths

42 modContents <- staticModuleFile modName paths

35− writeCabalProject target $ SimplePkg

43+ T.writeFile (moduleDirPath </> T.unpack modName' <.> "hs") modContents

36− { _simplePkg_name = _staticConfig_packageName cfg

44+

37− , _simplePkg_moduleName = _staticConfig_moduleName cfg

45+staticCabalFile :: StaticConfig -> Text

38− , _simplePkg_moduleContents = modContents

46+staticCabalFile cfg = T.unlines

39− , _simplePkg_dependencies = ["base", "ghc-prim", "text"]

47+ [ "name: " <> _staticConfig_packageName cfg

40− }

48+ , "version: 0"

49+ , "cabal-version: >= 1.2"

50+ , "build-type: Simple"

51+ , ""

52+ , "library"

53+ , " hs-source-dirs: src"

54+ , " build-depends:"

55+ , " base,"

56+ , " ghc-prim,"

57+ , " text"

58+ , " exposed-modules: " <> _staticConfig_moduleName cfg

59+ ]

41

60

42staticModuleFile :: Text -> Map FilePath FilePath -> IO Text

61staticModuleFile :: Text -> Map FilePath FilePath -> IO Text

43staticModuleFile moduleName paths = do

62staticModuleFile moduleName paths = do

@@ -50,7 +69,7 @@ staticModuleFile moduleName paths = do

50 , "{-# LANGUAGE OverloadedStrings #-}"

69 , "{-# LANGUAGE OverloadedStrings #-}"

51 , "{-# LANGUAGE ScopedTypeVariables #-}"

70 , "{-# LANGUAGE ScopedTypeVariables #-}"

52 , "{-# LANGUAGE TypeApplications #-}"

71 , "{-# LANGUAGE TypeApplications #-}"

53− , "module " <> moduleName <> " {-# DEPRECATED \"Generate this module with the 'obelisk-asset-th-generate' executable instead.\" #-} where"

72+ , "module " <> moduleName <> " where"

54 , ""

73 , ""

55 , "import qualified GHC.Types"

74 , "import qualified GHC.Types"

56 , "import Data.Text (Text)"

75 , "import Data.Text (Text)"

lib/asset/manifest/src/Obelisk/Asset/TH.hs+3−25

@@ -1,36 +1,14 @@

1−{-|

2−Description:

3− Template Haskell for generating asset paths.

4−-}

5module Obelisk.Asset.TH

1module Obelisk.Asset.TH

6 ( assetPath

2 ( assetPath

7− , staticAssetRaw

8− , staticAssetHashed

9 ) where

3 ) where

10

4

11import Obelisk.Asset.Gather

5import Obelisk.Asset.Gather

12

6

13−import Language.Haskell.TH

14import Language.Haskell.TH.Syntax

7import Language.Haskell.TH.Syntax

15import System.FilePath.Posix

8import System.FilePath.Posix

16

9

17−-- | Produces the hashed path of a file

18−hashedAssetFilePath :: FilePath -> FilePath -> Q FilePath

19−hashedAssetFilePath root relativePath = do

20− qAddDependentFile $ root </> relativePath

21− runIO (toHashedPath root relativePath)

22−

23-- | Produces a string literal with the hashed path of the file

10-- | Produces a string literal with the hashed path of the file

24assetPath :: FilePath -> FilePath -> Q Exp

11assetPath :: FilePath -> FilePath -> Q Exp

25−assetPath root relativePath =

12+assetPath root relativePath = do

26− LitE . StringL <$> hashedAssetFilePath root relativePath

13+ qAddDependentFile $ root </> relativePath

27−

14+ LitE . StringL <$> runIO (toHashedPath root relativePath)

28−staticPrefix :: FilePath

29−staticPrefix = "/static"

30−

31−staticAssetRaw :: FilePath -> Q Exp

32−staticAssetRaw fp = returnQ $ LitE $ StringL $ staticPrefix </> fp

33−

34−staticAssetHashed :: FilePath -> FilePath -> Q Exp

35−staticAssetHashed root fp = do

36− LitE . StringL . (staticPrefix </>) <$> hashedAssetFilePath root fp

lib/cliapp/src/Obelisk/CliApp/Logging.hs+1−5

@@ -44,7 +44,7 @@ import Data.Text (Text)

44import qualified Data.Text as T

45import qualified Data.Text.IO as T

46import GHC.IO.Encoding.Types

47−import System.Console.ANSI (Color (..), ColorIntensity (Vivid),

47+import System.Console.ANSI (Color (Red, Yellow), ColorIntensity (Vivid),

48 ConsoleIntensity (FaintIntensity), ConsoleLayer (Foreground),

49 SGR (SetColor, SetConsoleIntensity), clearLine)

50import System.Exit (ExitCode (..))

@@ -184,8 +184,6 @@ writeLog withNewLine noColor (WithSeverity severity s) = if T.null s then pure (

184 | noColor && severity <= Warning = liftIO $ putFn $ T.pack (show severity) <> ": " <> s

185 | not noColor && severity <= Error = TS.putStrWithSGR errorColors h withNewLine s

186 | not noColor && severity <= Warning = TS.putStrWithSGR warningColors h withNewLine s

187− | not noColor && severity == Notice = TS.putStrWithSGR noticeColors h withNewLine s

188− | not noColor && severity == Informational = TS.putStrWithSGR infoColors h withNewLine s

189 | not noColor && severity >= Debug = TS.putStrWithSGR debugColors h withNewLine s

187 | not noColor && severity >= Debug = TS.putStrWithSGR debugColors h withNewLine s

190 | otherwise = liftIO $ putFn s

188 | otherwise = liftIO $ putFn s

191

189

@@ -193,8 +191,6 @@ writeLog withNewLine noColor (WithSeverity severity s) = if T.null s then pure (

193 h = if severity <= Error then stderr else stdout

191 h = if severity <= Error then stderr else stdout

194 errorColors = [SetColor Foreground Vivid Red]

192 errorColors = [SetColor Foreground Vivid Red]

195 warningColors = [SetColor Foreground Vivid Yellow]

193 warningColors = [SetColor Foreground Vivid Yellow]

196− infoColors = [SetColor Foreground Vivid Green]

197− noticeColors = [SetColor Foreground Vivid Blue]

198 debugColors = [SetConsoleIntensity FaintIntensity]

194 debugColors = [SetConsoleIntensity FaintIntensity]

199

195

200-- | Allow the user to immediately switch to verbose logging upon pressing a particular key.

196-- | Allow the user to immediately switch to verbose logging upon pressing a particular key.

lib/command/obelisk-command.cabal−3

@@ -20,7 +20,6 @@ library

20 , exceptions

21 , extra

22 , filepath

23− , fsnotify

24 , git

23 , git

25 , github

24 , github

26 , here

25 , here

@@ -40,8 +39,6 @@ library

40 , optparse-applicative

39 , optparse-applicative

41 , placeholders

40 , placeholders

42 , process

41 , process

43− , reflex

44− , reflex-fsnotify

45 , shell-escape

42 , shell-escape

46 , temporary

43 , temporary

47 , terminal-size

44 , terminal-size

lib/command/src/Obelisk/Command/Project.hs+8−87

@@ -1,9 +1,6 @@

1{-# LANGUAGE FlexibleContexts #-}

2{-# LANGUAGE LambdaCase #-}

3{-# LANGUAGE OverloadedStrings #-}

4−{-# LANGUAGE ScopedTypeVariables #-}

5−{-# LANGUAGE TupleSections #-}

6−

7module Obelisk.Command.Project

4module Obelisk.Command.Project

8 ( InitSource (..)

5 ( InitSource (..)

9 , findProjectObeliskCommand

6 , findProjectObeliskCommand

@@ -19,17 +16,12 @@ module Obelisk.Command.Project

19 , toObeliskDir

16 , toObeliskDir

20 , withProjectRoot

17 , withProjectRoot

21 , bashEscape

18 , bashEscape

22− , getHaskellManifestProjectPath

23− , AssetSource(..)

24− , describeImpureAssetSource

25− , watchStaticFilesDerivation

26 ) where

19 ) where

27

20

28import Control.Concurrent.MVar (MVar, newMVar, withMVarMasked)

21import Control.Concurrent.MVar (MVar, newMVar, withMVarMasked)

29−import Control.Lens ((.~), (?~), (<&>), (^.), _3)

22+import Control.Lens ((.~), (?~), (<&>))

30import Control.Monad

23import Control.Monad

31import Control.Monad.IO.Class (liftIO)

24import Control.Monad.IO.Class (liftIO)

32−import Control.Monad.Log

33import Control.Monad.State

25import Control.Monad.State

34import qualified Data.Aeson as Json

26import qualified Data.Aeson as Json

35import qualified Data.ByteString.UTF8 as BSU

27import qualified Data.ByteString.UTF8 as BSU

@@ -42,25 +34,20 @@ import Data.Text (Text)

42import qualified Data.Text as T

34import qualified Data.Text as T

43import Data.Text.Encoding (decodeUtf8, encodeUtf8)

35import Data.Text.Encoding (decodeUtf8, encodeUtf8)

44import Data.Traversable (for)

36import Data.Traversable (for)

45−import Reflex

46−import Reflex.FSNotify

47−import Reflex.Host.Headless

48import System.Directory

37import System.Directory

49import System.Environment (lookupEnv)

38import System.Environment (lookupEnv)

50import System.FilePath

39import System.FilePath

51−import System.FSNotify (defaultConfig)

52import System.IO.Temp

40import System.IO.Temp

53import System.IO.Unsafe (unsafePerformIO)

41import System.IO.Unsafe (unsafePerformIO)

54import System.PosixCompat.Files

42import System.PosixCompat.Files

55import System.PosixCompat.Types

43import System.PosixCompat.Types

56import System.PosixCompat.User

44import System.PosixCompat.User

57−import qualified System.Process as Proc

58import Text.ShellEscape (bash, bytes)

45import Text.ShellEscape (bash, bytes)

59

46

60import GitHub.Data.GitData (Branch)

47import GitHub.Data.GitData (Branch)

61import GitHub.Data.Name (Name)

48import GitHub.Data.Name (Name)

62

49

63−import Obelisk.App (MonadObelisk, runObelisk, getObelisk)

50+import Obelisk.App (MonadObelisk)

64import Obelisk.CliApp

51import Obelisk.CliApp

65import Obelisk.Command.Nix

52import Obelisk.Command.Nix

66import Obelisk.Command.Thunk

53import Obelisk.Command.Thunk

@@ -347,21 +334,7 @@ nixShellWithHoogle root isPure shell' command = do

347 \})).project.shells.${shell}"

334 \})).project.shells.${shell}"

348 & nixShellConfig_common . nixCmdConfig_args .~ [ strArg "shell" shell' ]

335 & nixShellConfig_common . nixCmdConfig_args .~ [ strArg "shell" shell' ]

349

336

350−-- | Describes the provenance of static assets (i.e., are they the result of a derivation

351−-- that was built, or just a folder full of files.

352−data AssetSource = AssetSource_Derivation

353− | AssetSource_Files

354− deriving (Eq)

355−

356−-- | Some log messages to make it easier to tell where static files are coming from

357−describeImpureAssetSource :: AssetSource -> Text -> Text

358−describeImpureAssetSource src path = case src of

359− AssetSource_Files -> "Assets impurely loaded from: " <> path

360− AssetSource_Derivation -> "Assets derivation built and impurely loaded from: " <> path

361−

362−-- | Determine where the static files of a project are and whether they're plain files or a derivation.

363−-- If they are a derivation, that derivation will be built.

364−findProjectAssets :: MonadObelisk m => FilePath -> m (AssetSource, Text)

337+findProjectAssets :: MonadObelisk m => FilePath -> m Text

365findProjectAssets root = do

338findProjectAssets root = do

366 isDerivation <- readProcessAndLogStderr Debug $ setCwd (Just root) $

339 isDerivation <- readProcessAndLogStderr Debug $ setCwd (Just root) $

367 proc nixExePath

340 proc nixExePath

@@ -373,62 +346,10 @@ findProjectAssets root = do

373 ]

346 ]

374 -- Check whether the impure static files are a derivation (and so must be built)

347 -- Check whether the impure static files are a derivation (and so must be built)

375 if isDerivation == "1"

348 if isDerivation == "1"

376− then do

377− _ <- buildStaticFilesDerivationAndSymlink root

378− pure (AssetSource_Derivation, T.pack $ root </> "static.out")

379− else fmap (AssetSource_Files,) $ readProcessAndLogStderr Debug $ setCwd (Just root) $

380− proc nixExePath ["eval", "-f", ".", "passthru.staticFilesImpure", "--raw"]

381−

382−-- | Get the nix store path to the generated static asset manifest module (e.g., "obelisk-generated-static")

383−getHaskellManifestProjectPath :: MonadObelisk m => FilePath -> m Text

384−getHaskellManifestProjectPath root = fmap T.strip $ readProcessAndLogStderr Debug $ setCwd (Just root) $

349+ then fmap T.strip $ readProcessAndLogStderr Debug $ setCwd (Just root) $ -- Strip whitespace here because nix-build has no --raw option

385− proc nixBuildExePath

350+ proc nixBuildExePath

386− [ "--no-out-link"

351+ [ "--no-out-link"

387− , "-E"

388− , "(let a = import ./. {}; in a.passthru.processedStatic.haskellManifest)"

389− ]

390−

391−-- | Watch the project directory for file changes and check whether those file changes

392−-- cause changes in the static files nix derivation. If so, rebuild it.

393−watchStaticFilesDerivation

394− :: (MonadIO m, MonadObelisk m)

395− => FilePath

396− -> m ()

397−watchStaticFilesDerivation root = do

398− ob <- getObelisk

399− drv0 <- showDerivation

400− liftIO $ runHeadlessApp $ do

401− pb <- getPostBuild

402− checkForChanges <- watchDirectoryTree defaultConfig (root <$ pb) (const True)

403− drv <- performEvent $ ffor checkForChanges $ \_ ->

404− liftIO $ runObelisk ob showDerivation

405− drvs <- foldDyn (\new (_, old, _) -> (old, new, old /= new)) (drv0, drv0, False) drv

406− out <- throttleBatchWithLag

407− (\e -> performEvent $ ffor e $ \_ -> liftIO $ runObelisk ob $

408− buildStaticFilesDerivationAndSymlink root >> pure ())

409− (void $ ffilter (^._3) $ updated drvs)

410− performEvent_ $ ffor out $ \_ -> runObelisk ob $

411− putLog Notice "Static assets rebuilt and symlinked to static.out"

412− pure never

413− where

414− showDerivation :: MonadObelisk m => m Text

415− showDerivation = readProcessAndLogStderr Debug $

416− setCwd (Just root) $ ProcessSpec

417− { _processSpec_createProcess = Proc.proc nixExePath

418− [ "show-derivation"

419− , "-f", "."

420− , "passthru.staticFilesImpure"

421− ]

422− , _processSpec_overrideEnv = Nothing

423− }

424−

425−buildStaticFilesDerivationAndSymlink :: MonadObelisk m => FilePath -> m Text

426−buildStaticFilesDerivationAndSymlink root = readProcessAndLogStderr Debug $

427− setCwd (Just root) $ ProcessSpec

428− { _processSpec_createProcess = Proc.proc

429− nixBuildExePath

430− [ "-o", "static.out"

431 , "-E", "(import ./. {}).passthru.staticFilesImpure"

352 , "-E", "(import ./. {}).passthru.staticFilesImpure"

432 ]

353 ]

433− , _processSpec_overrideEnv = Nothing

354+ else readProcessAndLogStderr Debug $ setCwd (Just root) $

434− }

355+ proc nixExePath ["eval", "-f", ".", "passthru.staticFilesImpure", "--raw"]

lib/command/src/Obelisk/Command/Run.hs+10−28

@@ -14,8 +14,7 @@ module Obelisk.Command.Run where

14import Control.Arrow ((&&&))

15import Control.Exception (Exception, bracket)

16import Control.Lens (ifor, (.~), (&))

17−import Control.Concurrent (forkIO)

17+import Control.Monad (filterM)

18−import Control.Monad (filterM, void)

19import Control.Monad.Except (runExceptT, throwError)

18import Control.Monad.Except (runExceptT, throwError)

20import Control.Monad.IO.Class (liftIO)

19import Control.Monad.IO.Class (liftIO)

21import Control.Monad.Reader (MonadIO)

20import Control.Monad.Reader (MonadIO)

@@ -64,23 +63,21 @@ import System.FilePath

64import qualified System.Info

63import qualified System.Info

65import System.IO.Temp (withSystemTempDirectory)

64import System.IO.Temp (withSystemTempDirectory)

66

65

67−import Obelisk.App (MonadObelisk, getObelisk, runObelisk)

66+import Obelisk.App (MonadObelisk)

68import Obelisk.CliApp (

67import Obelisk.CliApp (

69 Severity (..),

68 Severity (..),

70 failWith,

69 failWith,

71− getCliConfig,

72 proc,

70 proc,

73 putLog,

71 putLog,

74 readCreateProcessWithExitCode,

72 readCreateProcessWithExitCode,

75 readProcessAndLogStderr,

73 readProcessAndLogStderr,

76− runCli,

77 runProcess_,

74 runProcess_,

78 setCwd,

75 setCwd,

79 setDelegateCtlc,

76 setDelegateCtlc,

80 withSpinner,

77 withSpinner,

81 )

78 )

82import Obelisk.Command.Nix

79import Obelisk.Command.Nix

83−import Obelisk.Command.Project

80+import Obelisk.Command.Project (nixShellWithoutPkgs, withProjectRoot, findProjectAssets, bashEscape)

84import Obelisk.Command.Thunk (attrCacheFileName)

81import Obelisk.Command.Thunk (attrCacheFileName)

85import Obelisk.Command.Utils (findExePath, ghcidExePath)

82import Obelisk.Command.Utils (findExePath, ghcidExePath)

86

83

@@ -147,8 +144,8 @@ profile profileBasePattern rtsFlags = withProjectRoot "." $ \root -> do

147 , _target_attr = Just "__unstable__.profiledObRun"

144 , _target_attr = Just "__unstable__.profiledObRun"

148 , _target_expr = Nothing

145 , _target_expr = Nothing

149 }

146 }

150− (assetType, assets) <- findProjectAssets root

147+ assets <- findProjectAssets root

151− putLog Debug $ describeImpureAssetSource assetType assets

148+ putLog Debug $ "Assets impurely loaded from: " <> assets

152 time <- liftIO getCurrentTime

149 time <- liftIO getCurrentTime

153 let profileBaseName = formatTime defaultTimeLocale profileBasePattern time

150 let profileBaseName = formatTime defaultTimeLocale profileBasePattern time

154 liftIO $ createDirectoryIfMissing True $ takeDirectory $ root </> profileBaseName

151 liftIO $ createDirectoryIfMissing True $ takeDirectory $ root </> profileBaseName

@@ -166,17 +163,9 @@ profile profileBasePattern rtsFlags = withProjectRoot "." $ \root -> do

166run :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()

163run :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()

167run root interpretPaths = do

164run root interpretPaths = do

168 pkgs <- getParsedLocalPkgs root interpretPaths

165 pkgs <- getParsedLocalPkgs root interpretPaths

169− (assetType, assets) <- findProjectAssets root

166+ assets <- findProjectAssets root

170− manifestPkg <- parsePackagesOrFail . (:[]) . T.unpack =<< getHaskellManifestProjectPath root

167+ putLog Debug $ "Assets impurely loaded from: " <> assets

171− putLog Debug $ describeImpureAssetSource assetType assets

172− case assetType of

173− AssetSource_Derivation -> do

174− cliConfig <- getCliConfig

175− ob <- getObelisk

176− putLog Debug "Starting static file derivation watcher..."

177− void $ liftIO $ forkIO $ runCli cliConfig $ runObelisk ob $ watchStaticFilesDerivation root

178− _ -> pure ()

179− ghciArgs <- getGhciSessionSettings (pkgs <> manifestPkg) root True

168+ ghciArgs <- getGhciSessionSettings pkgs root True

180 freePort <- getFreePort

169 freePort <- getFreePort

181 withGhciScriptArgs pkgs $ \dotGhciArgs -> do

170 withGhciScriptArgs pkgs $ \dotGhciArgs -> do

182 runGhcid root True (ghciArgs <> dotGhciArgs) pkgs $ Just $ unwords

171 runGhcid root True (ghciArgs <> dotGhciArgs) pkgs $ Just $ unwords

@@ -233,12 +222,7 @@ getLocalPkgs root interpretPaths = do

233 let rootsAndExclusions = calcIntepretFinds "" interpretPaths

222 let rootsAndExclusions = calcIntepretFinds "" interpretPaths

234

223

235 fmap fold $ for (MMap.toAscList rootsAndExclusions) $ \(interpretPathRoot, exclusions) ->

224 fmap fold $ for (MMap.toAscList rootsAndExclusions) $ \(interpretPathRoot, exclusions) ->

236− let allExclusions = obeliskPackageExclusions

225+ let allExclusions = obeliskPackageExclusions <> exclusions <> Set.singleton ("*" </> attrCacheFileName)

237− <> exclusions

238− <> Set.singleton ("*" </> attrCacheFileName)

239− <> Set.singleton ("*" </> "lib/asset/manifest") -- NB: obelisk-asset-manifest is excluded because it generates

240− -- a module that in turn imports it. This will cause ob run to

241− -- fail in its current implementation.

242 in fmap (Set.fromList . map normalise) $ runFind $

226 in fmap (Set.fromList . map normalise) $ runFind $

243 ["-L", interpretPathRoot, "(", "-name", "*.cabal", "-o", "-name", Hpack.packageConfig, ")", "-a", "-type", "f"]

227 ["-L", interpretPathRoot, "(", "-name", "*.cabal", "-o", "-name", Hpack.packageConfig, ")", "-a", "-type", "f"]

244 <> concat [["-not", "-path", p </> "*"] | p <- toList allExclusions]

228 <> concat [["-not", "-path", p </> "*"] | p <- toList allExclusions]

@@ -416,8 +400,7 @@ withGhciScriptArgs

416 => f CabalPackageInfo -- ^ List of packages to load into ghci

400 => f CabalPackageInfo -- ^ List of packages to load into ghci

417 -> ([String] -> m ()) -- ^ Action to run with the extra ghci arguments

401 -> ([String] -> m ()) -- ^ Action to run with the extra ghci arguments

418 -> m ()

402 -> m ()

419−withGhciScriptArgs packageInfos f = withGhciScript loadPreludeManually packageInfos $ \fp ->

403+withGhciScriptArgs packageInfos f = withGhciScript loadPreludeManually packageInfos $ \fp -> f ["-XNoImplicitPrelude", "-ghci-script", fp]

420− f ["-XNoImplicitPrelude", "-ghci-script", fp]

421 where

404 where

422 -- These lines must be first and allow the session to support a custom Prelude when @-XNoImplicitPrelude@

405 -- These lines must be first and allow the session to support a custom Prelude when @-XNoImplicitPrelude@

423 -- is passed to the ghci session.

406 -- is passed to the ghci session.

@@ -475,7 +458,6 @@ getGhciSessionSettings (toList -> packageInfos) pathBase useRelativePaths = do

475

458

476 pure

459 pure

477 $ baseGhciOptions

460 $ baseGhciOptions

478− <> ["-DOBELISK_ASSET_PASSTHRU"] -- For passthrough static assets

479 <> ["-F", "-pgmF", selfExe, "-optF", preprocessorIdentifier]

461 <> ["-F", "-pgmF", selfExe, "-optF", preprocessorIdentifier]

480 <> concatMap (\p -> ["-optF", p]) pkgFiles

462 <> concatMap (\p -> ["-optF", p]) pkgFiles

481 <> [ "-i" <> intercalate ":" (concatMap toList pkgSrcPaths) ]

463 <> [ "-i" <> intercalate ":" (concatMap toList pkgSrcPaths) ]

skeleton/frontend/src/Frontend.hs+4−3

@@ -1,5 +1,6 @@

1+{-# LANGUAGE DataKinds #-}

1{-# LANGUAGE OverloadedStrings #-}

2{-# LANGUAGE OverloadedStrings #-}

2−{-# LANGUAGE TemplateHaskell #-}

3+{-# LANGUAGE TypeApplications #-}

3

4

4module Frontend where

5module Frontend where

5

6

@@ -26,7 +27,7 @@ frontend :: Frontend (R FrontendRoute)

26frontend = Frontend

27frontend = Frontend

27 { _frontend_head = do

28 { _frontend_head = do

28 el "title" $ text "Obelisk Minimal Example"

29 el "title" $ text "Obelisk Minimal Example"

29− elAttr "link" ("href" =: $(static "main.css") <> "type" =: "text/css" <> "rel" =: "stylesheet") blank

30+ elAttr "link" ("href" =: static @"main.css" <> "type" =: "text/css" <> "rel" =: "stylesheet") blank

30 , _frontend_body = do

31 , _frontend_body = do

31 el "h1" $ text "Welcome to Obelisk!"

32 el "h1" $ text "Welcome to Obelisk!"

32 el "p" $ text $ T.pack commonStuff

33 el "p" $ text $ T.pack commonStuff

@@ -37,7 +38,7 @@ frontend = Frontend

37 -- print "Hello, World!" on the client.

38 -- print "Hello, World!" on the client.

38 prerender_ blank $ liftJSM $ void $ eval ("console.log('Hello, World!')" :: T.Text)

39 prerender_ blank $ liftJSM $ void $ eval ("console.log('Hello, World!')" :: T.Text)

39

40

40− elAttr "img" ("src" =: $(static "obelisk.jpg")) blank

41+ elAttr "img" ("src" =: static @"obelisk.jpg") blank

41 el "div" $ do

42 el "div" $ do

42 exampleConfig <- getConfig "common/example"

43 exampleConfig <- getConfig "common/example"

43 case exampleConfig of

44 case exampleConfig of