git.iko.soy/obelisk
on master help sign in
swap
7ad33cb222 ahead, 0 behind
.github/pull_request_template.md+2
since splitsnapshots
unifiedsplit
@@ -3,6 +3,8 @@
3I have:
3I have:
4
4
5 - [ ] Based work on latest `develop` branch
5 - [ ] Based work on latest `develop` branch
6+ - [ ] Followed the [contribution guide](https://github.com/obsidiansystems/obelisk/blob/develop/CONTRIBUTING.md#submitting-changes)
6 - [ ] Looked for lint in my changes with `hlint .` (lint found code you did not write can be left alone)
7 - [ ] Looked for lint in my changes with `hlint .` (lint found code you did not write can be left alone)
7 - [ ] Run the test suite: `$(nix-build -A selftest --no-out-link)`
8 - [ ] Run the test suite: `$(nix-build -A selftest --no-out-link)`
9+ - [ ] [Updated the changelog](https://github.com/obsidiansystems/obelisk/blob/develop/CONTRIBUTING.md#in-the-changelog)
8 - [ ] (Optional) Run CI tests locally: `nix-build release.nix -A build.x86_64-linux --no-out-link` (or `x86_64-darwin` on macOS)
10 - [ ] (Optional) Run CI tests locally: `nix-build release.nix -A build.x86_64-linux --no-out-link` (or `x86_64-darwin` on macOS)
CONTRIBUTING.md+52
@@ -8,6 +8,7 @@ Contributions and issue reports are encouraged and appreciated!
8 - [Guidelines for Pull Requests](#guidelines-for-pull-requests)
8 - [Guidelines for Pull Requests](#guidelines-for-pull-requests)
9 - [Code Quality](#code-quality)
9 - [Code Quality](#code-quality)
10 - [Documentation](#documentation)
10 - [Documentation](#documentation)
11+- [Development Environment](#development-environment)
11
12
12## Opening Issues
13## Opening Issues
13
14
@@ -39,6 +40,7 @@ For breaking changes, new features, refactors, or other major changes, the body
39
40
40Wherever possible, pull requests should add a single feature or fix a single bug. Pull requests should not bundle several unrelated changes.
41Wherever possible, pull requests should add a single feature or fix a single bug. Pull requests should not bundle several unrelated changes.
41
42
43+
42### Code Quality
44### Code Quality
43
45
44#### Warnings
46#### Warnings
@@ -77,3 +79,53 @@ Add an entry to the changelog when your PR:
77#### In the [Readme](README.md)
79#### In the [Readme](README.md)
78The readme is the first place a lot of people look for information about the repository. Update any parts of the readme that are affected by your PR.
80The readme is the first place a lot of people look for information about the repository. Update any parts of the readme that are affected by your PR.
79
81
82+
83+## Development Environment
84+
85+There are two ways to get live compiler feedback while developing Obelisk libraries. For libraries that are dependencies of the `skeleton` application, the easiest way to get feedback is to
86+
87+```bash
88+cd skeleton
89+ob run
90+```
91+
92+This `ob run` session only loads modules that are dependencies of the skeleton and `obelisk-run`. For example, `obelisk-asset` and `obelisk-route` are used by the skeleton.
93+
94+For other libraries like `obelisk-command` you can use `ghcid`. To launch `ghcid` for `lib/command` you can run
95+
96+```bash
97+nix-shell -A obeliskEnvs.obelisk-command --run "cd lib/command && ghcid"
98+```
99+
100+### Building `ob` for testing
101+
102+To re-install `ob` from source globally you can do
103+
104+```bash
105+nix-env -f /path/to/obelisk -iA command
106+```
107+
108+You can also open a shell with the local version of `ob` available on your `$PATH`:
109+
110+```bash
111+nix run -f /path/to/obelisk command
112+```
113+
114+### Hacking on Obelisk from within an Obelisk project
115+
116+`ob` will defer to the version found in your project's `.obelisk/impl` directory. To work on that version specifically:
117+
118+```bash
119+ob thunk unpack ./.obelisk/impl
120+cd ./.obelisk/impl
121+# apply your changes
122+```
123+
124+If you want to commit your changes, first push them to your fork of obelisk and then
125+
126+```bash
127+cd /your/project/root
128+ob thunk pack .obelisk/impl
129+git add .obelisk/impl
130+git commit -m "Bump obelisk"
131+```
ChangeLog.md+30−4
@@ -2,20 +2,46 @@
2
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.
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
4
5−## Unreleased
5+## v0.9.1.0
6
6
7+* [#801](https://github.com/obsidiansystems/obelisk/pull/801): Remove errors and warning for local packages without a library component
8+* [#812](https://github.com/obsidiansystems/obelisk/pull/812): Add support for `NoImplicitPrelude` and other extensions disabled via `No`
9+* Pinned version bumps:
10+ * reflex-platform [0.7.0.0](https://github.com/reflex-frp/reflex-platform/releases/tag/v0.7.0.0)
11+ * hnix 0.8.0
12+* [#787](https://github.com/obsidiansystems/obelisk/pull/787): Set `immutable` cache control directive when serving content-addressed static assets
13+* Use iOS SDK 13.2
14+
15+
16+## v0.9.0.1
17+
18+* ([#810](https://github.com/obsidiansystems/obelisk/pull/810)) Fix loading of `all.js` in fully compiled web apps.
19+
20+## v0.9.0.0
21+
22+* **(Breaking change)** Backport nixpkgs upgrades to ACME/Let's Encrypt handling so that HTTPS deployments continue to work flawlessly. If your deployment is having trouble renewing [Let's Encrypt](https://letsencrypt.org/) certificates, upgrade to this version.
23+ * **IMPORTANT:** In order to use [Let's Encrypt](https://letsencrypt.org/) you must now accept their [terms of service](https://letsencrypt.org/repository/). To do that, add `terms.security.acme.acceptTerms = true;` to the `import ./.obelisk/impl {` section in your `default.nix`. The new skeleton application may serve as an [example](https://github.com/obsidiansystems/obelisk/blob/4759342ab3570888c027d4c58cb5694cb832d624/skeleton/default.nix#L13).
24+* Update reflex-platform dependency to v0.6.0.0
7* ([#715](https://github.com/obsidiansystems/obelisk/pull/715)) In `Obelisk.Route` deprecate `isoEncoder` and `prismEncoder` in favor of more precisely named `viewEncoder` and `reviewEncoder` (respectively) and improve documentation regarding contravariance of `reviewEncoder`.
25* ([#715](https://github.com/obsidiansystems/obelisk/pull/715)) In `Obelisk.Route` deprecate `isoEncoder` and `prismEncoder` in favor of more precisely named `viewEncoder` and `reviewEncoder` (respectively) and improve documentation regarding contravariance of `reviewEncoder`.
26+* ([#739](https://github.com/obsidiansystems/obelisk/pull/739)) Improve `ob shell` by allowing commands to be passed verbatim after a `--` argument. For example, `ob shell 'run command'` can now be written `ob shell -- run command`.
27+* ([#735](https://github.com/obsidiansystems/obelisk/pull/735)) Fix regression causing custom `Prelude`s to break `ob run`/`ob watch`/`ob repl`.
28+* ([#737](https://github.com/obsidiansystems/obelisk/pull/737)) Fix bug causing custom `Prelude`s to break `ob profile`.
29+* ([#752](https://github.com/obsidiansystems/obelisk/pull/752)) Fix the `ob` command-line tool to return non-zero exit code when underlying processes fail.
30+* ([#742](https://github.com/obsidiansystems/obelisk/pull/742), [#57](https://github.com/obsidiansystems/obelisk/pull/57), [#406](https://github.com/obsidiansystems/obelisk/pull/406)) Enable `-dedupe` and `-DGHCJS_BROWSER` in GHCJS builds to make JavaScript output considerably smaller leading to faster load/parse times and faster build times.
31+ * **Migration:** New Obelisk projects will automatically benefit from this change, but existing projects need to apply a change similar to [this one](https://github.com/obsidiansystems/obelisk/blob/371cb3302085601c5ec73e9574d51c8b95e3e493/skeleton/frontend/frontend.cabal#L32-L34).
32+* ([#742](https://github.com/obsidiansystems/obelisk/pull/742)) Update `reflex-platform` which includes:
33+ * A new version of GHCJS where `-dedupe` is fixed.
8
34
9## v0.8.0.0
35## v0.8.0.0
10
36
11−* ([#674](https://github.com/obsidiansystems/obelisk/pull/674), [#711](https://github.com/obsidiansystems/obelisk/pull/711)) Introduce a new thunk format to support accessing the thunk's source directly when packed. When packed, thunks have an additional file called `thunk.nix` and `default.nix` is now a think wrapper around that.
37+* ([#674](https://github.com/obsidiansystems/obelisk/pull/674), [#711](https://github.com/obsidiansystems/obelisk/pull/711)) Introduce a new thunk format to support accessing the thunk's source directly when packed. When packed, thunks have an additional file called `thunk.nix` and `default.nix` is now a thin wrapper around that.
12* ([#665](https://github.com/obsidiansystems/obelisk/pull/665)) Add `--interpret` and `--no-interpret` options to `ob run`/`ob watch`/`ob repl`/`ob shell`. These options allow you to pick which paths will be pre-compiled by `nix` when entering the shell/session and which won't. For example `ob run --no-interpret dep` will ensure that any dependencies found in `./dep` will be built by `nix` before loading the rest of the project into the `ghci` session. The same configuration for `ob shell` will ensure that those packages are built and available in the `ghc` package database inside the shell.
38* ([#665](https://github.com/obsidiansystems/obelisk/pull/665)) Add `--interpret` and `--no-interpret` options to `ob run`/`ob watch`/`ob repl`/`ob shell`. These options allow you to pick which paths will be pre-compiled by `nix` when entering the shell/session and which won't. For example `ob run --no-interpret dep` will ensure that any dependencies found in `./dep` will be built by `nix` before loading the rest of the project into the `ghci` session. The same configuration for `ob shell` will ensure that those packages are built and available in the `ghc` package database inside the shell.
13
39
14 **NOTE:** `ob shell`'s default behavior is now different. By default it now behaves like `ob run`/`ob watch`/`ob repl` in that it does *not* pre-build any packages whose `.cabal` or `package.yaml` files are found in the project. To regain the previous behavior, use `ob shell --no-interpret . --interpret backend --interpret common --interpret frontend` from the project root.
40 **NOTE:** `ob shell`'s default behavior is now different. By default it now behaves like `ob run`/`ob watch`/`ob repl` in that it does *not* pre-build any packages whose `.cabal` or `package.yaml` files are found in the project. To regain the previous behavior, use `ob shell --no-interpret . --interpret backend --interpret common --interpret frontend` from the project root.
15* ([#695](https://github.com/obsidiansystems/obelisk/pull/695)) `ob deploy init` now requires that your obelisk project be a clean `git` checkout with pushed changes. It has always required that your obelisk project be a `git` repository, but it did not require that your local changes be committed and pushed. This new requirement is added to ensure users don't accidentally create a deployment pointing to an old version of the project.
41* ([#695](https://github.com/obsidiansystems/obelisk/pull/695)) `ob deploy init` now requires that your obelisk project be a clean `git` checkout with pushed changes. It has always required that your obelisk project be a `git` repository, but it did not require that your local changes be committed and pushed. This new requirement is added to ensure users don't accidentally create a deployment pointing to an old version of the project.
16* ([#705](https://github.com/obsidiansystems/obelisk/pull/705)) Add `Obelisk.Route.packTextEncoder` and generalize `Obelisk.Route.unpackTextEncoder` over any `Data.Text.Lens.IsText`.
42* ([#705](https://github.com/obsidiansystems/obelisk/pull/705)) Add `Obelisk.Route.packTextEncoder` and generalize `Obelisk.Route.unpackTextEncoder` over any `Data.Text.Lens.IsText`.
17* ([#712](https://github.com/obsidiansystems/obelisk/pull/712)) Update [`reflex-platform`](https://github.com/reflex-frp/reflex-platform) to version 0.5.3.0.
43* ([#712](https://github.com/obsidiansystems/obelisk/pull/712)) Update [`reflex-platform`](https://github.com/reflex-frp/reflex-platform) to version 0.5.3.0.
18−* ([#700](https://github.com/obsidiansystems/obelisk/pull/700)) Ensure `ob init` uses the thunk format of the target obelisk rather than the one currently running the init command. If a user had installed a version of obelisk with a new thunk format, a newly initialized skeleton of an older version would not be able to unpack it's own `.obelisk/impl`.
44+* ([#700](https://github.com/obsidiansystems/obelisk/pull/700)) Ensure `ob init` uses the thunk format of the target obelisk rather than the one currently running the init command. If a user had installed a version of obelisk with a new thunk format, a newly initialized skeleton of an older version would not be able to unpack its own `.obelisk/impl`.
19* ([#693](https://github.com/obsidiansystems/obelisk/pull/693)) Fix a bug where some packages in `.attr-cache` directories would be incorrectly picked up and used instead of the correct ones when using `ob run`/`ob watch`/`ob repl`.
45* ([#693](https://github.com/obsidiansystems/obelisk/pull/693)) Fix a bug where some packages in `.attr-cache` directories would be incorrectly picked up and used instead of the correct ones when using `ob run`/`ob watch`/`ob repl`.
20* ([#709](https://github.com/obsidiansystems/obelisk/pull/709)) Fix a bug in obelisk's preprocessor causing it to incorrectly skip files in some circumstances.
46* ([#709](https://github.com/obsidiansystems/obelisk/pull/709)) Fix a bug in obelisk's preprocessor causing it to incorrectly skip files in some circumstances.
21* ([#663](https://github.com/obsidiansystems/obelisk/pull/663)) Add **experimental** support for [`ghcide`](https://github.com/digital-asset/ghcide). See the README for more information.
47* ([#663](https://github.com/obsidiansystems/obelisk/pull/663)) Add **experimental** support for [`ghcide`](https://github.com/digital-asset/ghcide). See the README for more information.
@@ -66,7 +92,7 @@ This project's release branch is `master`. This log is written from the perspect
66* Improve error messaging when a dependency doesn't have the expected `.cabal` or `package.yaml` file. ([#597](https://github.com/obsidiansystems/obelisk/pull/597))
92* Improve error messaging when a dependency doesn't have the expected `.cabal` or `package.yaml` file. ([#597](https://github.com/obsidiansystems/obelisk/pull/597))
67* Improve the skeleton in small ways. ([#593](https://github.com/obsidiansystems/obelisk/pull/593), [#589](https://github.com/obsidiansystems/obelisk/pull/589))
93* Improve the skeleton in small ways. ([#593](https://github.com/obsidiansystems/obelisk/pull/593), [#589](https://github.com/obsidiansystems/obelisk/pull/589))
68* Fix `ob` commands to again support running from any subdirectory of an obelisk project ([#591](https://github.com/obsidiansystems/obelisk/pull/591))
94* Fix `ob` commands to again support running from any subdirectory of an obelisk project ([#591](https://github.com/obsidiansystems/obelisk/pull/591))
69−* Add `reflex-platform-func` argument to Obelisk's `default.nix`. It defaults to it's prior behavior of using the reflex-platform in in `dep`. ([#612](https://github.com/obsidiansystems/obelisk/pull/612))
95+* Add `reflex-platform-func` argument to Obelisk's `default.nix`. It defaults to its prior behavior of using the reflex-platform in in `dep`. ([#612](https://github.com/obsidiansystems/obelisk/pull/612))
70
96
71## v0.3.0.0 - 2019-12-20
97## v0.3.0.0 - 2019-12-20
72
98
FAQ.md+62−67
@@ -1,14 +1,70 @@
1# Frequently Asked Questions
1# Frequently Asked Questions
2
2
3+1. [How do I declare a new Haskell dependency?](#how-do-i-declare-a-new-haskell-dependency)
4+1. [How do I add or override Haskell dependencies in the package set?](#how-do-i-add-or-override-haskell-dependencies-in-the-package-set)
5+1. [How do I extend my Obelisk application with more local packages?](#how-do-i-extend-my-obelisk-application-with-more-local-packages)
6+1. [How do I use `ob run` over HTTPS?](#how-do-i-use-ob-run-over-https)
3−1. [How do I fix invalid entitlements? ](#how-do-i-fix-invalid-entitlements)
7+1. [How do I fix invalid entitlements?](#how-do-i-fix-invalid-entitlements)
41. [`ob thunk update` or `ob deploy update` fails](#ob-thunk-update-or-ob-deploy-update-fails)
81. [`ob thunk update` or `ob deploy update` fails](#ob-thunk-update-or-ob-deploy-update-fails)
51. [How do I fix `Ambiguous module name` errors?](#how-do-i-fix-ambiguous-module-name-errors)
91. [How do I fix `Ambiguous module name` errors?](#how-do-i-fix-ambiguous-module-name-errors)
6−1. [What does `ob run` actually do?](#what-does-ob-run-actually-do)
10+
11+### How do I declare a new Haskell dependency?
12+
13+Every component of your Obelisk application is a standard [cabal](https://www.haskell.org/cabal/) package. That means declaring new Haskell dependencies simply involves updating the `build-depends` field in the appropriate cabal file (`backend.cabal` for example). By default, Obelisk will use its curated package set to choose which version of each package you get. It's possible that the package you need is not already in the curated set or the curated version isn't the one you want. See [How do I add or override Haskell dependencies in the package set?](#how-do-i-add-or-override-haskell-dependencies-in-the-package-set) for a solution to this.
14+
15+### How do I add or override Haskell dependencies in the package set?
16+
17+To add a Haskell package that doesn't exist in Obelisk's package set or to override the version of a package, use the `overrides` attribute in your project's `default.nix`. For example, to use a specific version of the `aeson` package fetched from GitHub and a specific version of the `waargonaut` package fetched from Hackage, your `default.nix` will look like:
18+
19+```nix
20+# ...
21+project ./. ({ pkgs, ... }: {
22+# ...
23+ overrides = self: super: let
24+ aesonSrc = pkgs.fetchFromGitHub {
25+ owner = "obsidiansystems";
26+ repo = "aeson-gadt-th";
27+ rev = "ed573c2cccf54d72aa6279026752a3fecf9c1383";
28+ sha256 = "08q6rnz7w9pn76jkrafig6f50yd0f77z48rk2z5iyyl2jbhcbhx3";
29+ };
30+ in
31+ {
32+ aeson = self.callCabal2nix "aeson" aesonSrc {};
33+ waargonaut = self.callHackageDirect {
34+ pkg = "waargonaut";
35+ ver = "0.8.0.1";
36+ sha256 = "1zv28np3k3hg378vqm89v802xr0g8cwk7gy3mr77xrzy5jbgpa39";
37+ } {};
38+ };
39+# ...
40+```
41+
42+For further information see [the Haskell section](https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure) of nixpkgs "Contributors Guide".
43+
44+### How do I extend my Obelisk application with more local packages?
45+
46+If the standard packages (`frontend`, `backend`, and `common`) are not enough, you may add more local packages by defining them with the `packages` attribute in your `default.nix`. The sources of these packages will be automatically loaded by `ob run`/`ob repl`/etc.
47+
48+```nix
49+# ...
50+project ./. ({ pkgs, ... }: {
51+# ...
52+ packages = {
53+ another = ./dep/another;
54+ };
55+# ...
56+```
57+
58+### How do I use `ob run` over HTTPS?
59+
60+To run your app locally over HTTPS, update the protocol in `config/common/route` to `https`, and then use `ob run` as normal.
61+
62+Obelisk generates a self-signed certificate for running HTTPS so the browser will issue a warning about using an invalid certificate. On Chrome, you can go to `chrome://flags/#allow-insecure-localhost` to enable invalid certificates for localhost.
63+
7
64
8### How do I fix invalid entitlements?
65### How do I fix invalid entitlements?
9
66
10−You probably did not set `ios.bundleIdentifier` correctly in `default.nix`.
67+You probably did not set `ios.bundleIdentifier` correctly in `default.nix`. When this happens you'll see an error something like this:
11−When this happens you'll see an error something like this:
12
68
13```
69```
142018-11-25 09:34:22.438 ios-deploy[58106:8521046] [ !! ] Error 0xe8008016: The executable was signed with invalid entitlements. AMDeviceSecureInstallApplication(0, device, url, options, install_callback, 0)
702018-11-25 09:34:22.438 ios-deploy[58106:8521046] [ !! ] Error 0xe8008016: The executable was signed with invalid entitlements. AMDeviceSecureInstallApplication(0, device, url, options, install_callback, 0)
@@ -19,7 +75,7 @@ Fixing the value of `ios.bundleIdentifier` should fix the error.
19### `ob thunk update` or `ob deploy update` fails
75### `ob thunk update` or `ob deploy update` fails
20Whenever an `ob` command fails, try re-running it with `-v`.
76Whenever an `ob` command fails, try re-running it with `-v`.
21
77
22−If you're using a private repo, and you get a failure in nix-prefetch-url, you may need to unpack and repack the thunk. Here's some example output that shows this issue:
78+If you're using a private repo, and you get a failure in `nix-prefetch-url`, you may need to unpack and repack the thunk. Here's some example output that shows this issue:
23
79
24```
80```
25Starting Obelisk </nix/store/j8wls8a89xr6s1a47lg6g83gnbdrfd0l-obelisk-command-0.1/bin/.ob-wrapped> args=["deploy","update","-v"] logging-level=Debug
81Starting Obelisk </nix/store/j8wls8a89xr6s1a47lg6g83gnbdrfd0l-obelisk-command-0.1/bin/.ob-wrapped> args=["deploy","update","-v"] logging-level=Debug
@@ -39,7 +95,7 @@ nix-prefetch-url: Failed to determine sha256 hash of URL https://github.com/obsi
39
95
40And here's how you can fix it:
96And here's how you can fix it:
41
97
42−```
98+```bash
43ob thunk unpack $SOME_THUNK
99ob thunk unpack $SOME_THUNK
44ob thunk pack $SOME_THUNK
100ob thunk pack $SOME_THUNK
45```
101```
@@ -59,64 +115,3 @@ error:
59```
115```
60then specify the package you want in the import, e.g:
116then specify the package you want in the import, e.g:
61`import "cryptonite" Crypto.Hash`
117`import "cryptonite" Crypto.Hash`
62−
63−
64−### What does `ob run` actually do?
65−
66−
67−#### Short version:
68−
69−`ob run` starts a [`ghcid`](https://github.com/ndmitchell/ghcid) process which
70−tries to build your project within a carefully crafted `nix-shell` with all the
71−project's dependencies and,
72−
73−* either displays compilation errors/warnings,
74−* or starts the Obelisk server, which serves:
75− * your backend's route handlers,
76− * the static assets,
77− * the [JSaddle](https://github.com/ghcjs/jsaddle) frontend code (while opening its websocket).
78−
79−#### Longer version:
80−
81−Assuming we are in a project created with `ob init`, `ob run` calls (see
82−`lib/command/src/Obelisk/Command.hs`):
83−
84− nix-shell --pure -A shells.ghc --run 'ob --no-handoff internal run-static-io <real-run-function>'
85−
86−where
87−
88−* `shells.ghc` is defined in `./default.nix` by importing `./.obelisk/impl/default.nix` which
89− is `default.nix` in the present (Obelisk) repository,
90−* `run-static-io` is a logging-enabled command wrapper
91− (cf. `runObelisk` in `lib/command/src/Obelisk/App.hs`).
92−
93−In this case, it runs the function `Obelisk.Command.Command.run` (defined in
94−`lib/command/src/Obelisk/Command/Run.hs`).
95−
96−* It creates a GHCi config from a Nix expression which:
97− * loads three packages: `backend`, `common`, `frontend`,
98− * obtains a free port number.
99−* Then runs `ghcid`
100− * with a command that reruns `Obelisk.Run.run` at each restart (option
101− `--test`).
102−
103−It is defined in `lib/run/src/Obelisk/Run.hs`:
104−
105−* It creates a thread which starts the main backend.
106− This runs `runSnapWithCommandLineArgs` and passes routes:
107− * to the backend (result of the `_backend_run` field of your
108− implementation of the `Backend fullRoute frontendRoute` record),
109− * or to `serveDefaultObeliskApp` (`lib/backend/src/Obelisk/Backend.hs`) to
110− serve static assets.
111−* Starts `runWidget`
112− which itself runs
113− [runSettingsSocket](https://hackage.haskell.org/package/warp-3.2.26/docs/Network-Wai-Handler-Warp.html#v:runSettingsSocket)
114− (the *“TCP listen loop”*):
115− * it binds to TCP socket, and
116− * creates the HTTP connection manager
117− ( [`newManager`](https://hackage.haskell.org/package/http-client-0.6.3/docs/Network-HTTP-Client.html#v:newManager))
118− * calls `obeliskApp` which
119− * has a route to serve the [JSaddle](https://github.com/ghcjs/jsaddle) frontend,
120− * runs the frontend (*on* the server), to produce pre-rendered pages,
121− * starts the JSaddle web-socket,
122− * “falls back” to proxying the backend (`fallbackProxy`).
README.md+68−167
@@ -1,96 +1,75 @@
1# Obelisk
1# Obelisk
2
2
3[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)](http://www.haskell.org)
3[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)](http://www.haskell.org)
4−[![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)](https://tldrlegal.com/license/bsd-3-clause-license-%28revised%29)
4+[![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)](https://github.com/obsidiansystems/obelisk/blob/master/LICENSE)
5
5
6+<p align="center"><img src="docs/obelisk-logo-640.png" width="50%" alt="Obelisk Logo"></p>
6
7
7−Obelisk provides an easy way to develop and deploy your [Reflex](https://github.com/reflex-frp/reflex) project as web apps and as mobile apps.
8+Functional reactive web and mobile applications, with batteries included. Obelisk's goal is to represent a cohesive, highly-curated set of choices that [Obsidian Systems](https://obsidian.systems/) has made for building these types of applications in a way that is extremely fast but does not compromise on production readiness.
8
9
10+- [Overview](#overview)
11+ - [Who should consider using it?](#who-should-consider-using-it)
9- [Installing Obelisk](#installing-obelisk)
12- [Installing Obelisk](#installing-obelisk)
10- [Developing an Obelisk project](#developing-an-obelisk-project)
13- [Developing an Obelisk project](#developing-an-obelisk-project)
11− - [Adding Packages](#adding-packages)
12− - [Adding Package Overrides](#adding-package-overrides)
13− - [Running over HTTPS](#running-over-https)
14 - [IDE Support](#ide-support)
14 - [IDE Support](#ide-support)
15− - [Terminal-based feedback](#terminal-based-feedback)
16− - [Experimental `ghcide` support](#experimental-ghcide-support)
17- [Deploying](#deploying)
15- [Deploying](#deploying)
18− - [Locally](#locally)
19 - [Default EC2 Deployment](#default-ec2-deployment)
16 - [Default EC2 Deployment](#default-ec2-deployment)
20 - [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)
17 - [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)
21 - [VirtualBox Deployment](#virtualbox-deployment)
18 - [VirtualBox Deployment](#virtualbox-deployment)
19+ - [Locally](#locally)
22 - [From macOS](#from-macos)
20 - [From macOS](#from-macos)
23 - [Deploying an updated version](#deploying-an-updated-version)
21 - [Deploying an updated version](#deploying-an-updated-version)
24- [Mobile](#mobile)
22- [Mobile](#mobile)
25 - [iOS](#ios)
23 - [iOS](#ios)
26 - [Android](#android)
24 - [Android](#android)
25+- [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)
26+- [Contributing](#contributing)
27+
28+## Overview
29+
30+Obelisk allows you to build high-quality web and mobile applications very quickly using [Reflex](https://reflex-frp.org/). In minutes you can go from an empty directory to an interactive application that works on web, iOS, and Android, all sharing the same Haskell codebase! Obelisk's development environment also enables extremely rapid development and feedback. You can take advantage of Haskell's type system across the frontend and backend boundary. This means changes to your backend that would break your frontend are immediately detected during development and vice versa. Obelisk uses Haskell's compiler to give you a complete "TODO list" of what needs to be updated.
31+
32+Obelisk is targeted primarily at Haskell developers who want to build high-quality web and/or mobile applications in Haskell, without the distractions of manually choosing and integrating technology for every piece of the system.
33+
34+### Who should consider using it?
35+
36+Obelisk assumes basic knowledge of [Haskell](https://www.haskell.org/) and [Reflex/Reflex-DOM](https://reflex-frp.org/), web technologies like [HTML](https://developer.mozilla.org/en-US/docs/Web/HTML) and [CSS](https://developer.mozilla.org/en-US/docs/Web/CSS), and a terminal shell like [Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)). Knowledge of [Nix](https://nixos.org/) helps but is not strictly necessary.
37+
27
38
28## Installing Obelisk
39## Installing Obelisk
40+
291. [Install Nix](https://nixos.org/nix/).
411. [Install Nix](https://nixos.org/nix/).
30 If you already have Nix installed, make sure you have version 2.0 or higher. To check your current version, run `nix-env --version`.
42 If you already have Nix installed, make sure you have version 2.0 or higher. To check your current version, run `nix-env --version`.
311. Set up nix caches
431. Set up nix caches
32 1. If you are running NixOS, add this to `/etc/nixos/configuration.nix`:
44 1. If you are running NixOS, add this to `/etc/nixos/configuration.nix`:
33− ```
45+ ```nix
34 nix.binaryCaches = [ "https://nixcache.reflex-frp.org" ];
46 nix.binaryCaches = [ "https://nixcache.reflex-frp.org" ];
35 nix.binaryCachePublicKeys = [ "ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=" ];
47 nix.binaryCachePublicKeys = [ "ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=" ];
36 ```
48 ```
37 and rebuild your NixOS configuration (e.g. `sudo nixos-rebuild switch`).
49 and rebuild your NixOS configuration (e.g. `sudo nixos-rebuild switch`).
38− 1. If you are using another operating system or linux distribution, ensure that these lines are present in your Nix configuration file (`/etc/nix/nix.conf` on most systems; [see full list](https://nixos.org/nix/manual/#sec-conf-file)):
50+ 1. If you are using another operating system or Linux distribution, ensure that these lines are present in your Nix configuration file (`/etc/nix/nix.conf` on most systems; [see full list](https://nixos.org/nix/manual/#sec-conf-file)):
39− ```
51+ ```nix
40− binary-caches = https://cache.nixos.org https://nixcache.reflex-frp.org
52+ binary-caches = https://cache.nixos.org https://nixcache.reflex-frp.org
41− binary-cache-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=
53+ binary-cache-public-keys = cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY= ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=
42− binary-caches-parallel-connections = 40
54+ binary-caches-parallel-connections = 40
43 ```
55 ```
44− * other Linux: enable sandboxing (see these [issue172](https://github.com/obsidiansystems/obelisk/issues/172#issuecomment-411507818) or [issue6](https://github.com/obsidiansystems/obelisk/issues/6) if you run into build problems)
56+ * If you're on a Linux distribution other than NixOS, enable sandboxing (see these [issue 172](https://github.com/obsidiansystems/obelisk/issues/172#issuecomment-411507818) or [issue 6](https://github.com/obsidiansystems/obelisk/issues/6) if you run into build problems) by adding the following:
45− ```
57+ ```nix
46 sandbox = true
58 sandbox = true
47 ```
59 ```
48− * MacOS: disable sandboxing (there are still some impure dependencies for now)
60+ * If you're on MacOS, disable sandboxing (there are still some impure dependencies for now) by adding the following:
49− ```
61+ ```nix
50 sandbox = false
62 sandbox = false
51 ```
63 ```
52 then restart the nix daemon
64 then restart the nix daemon
53− ```
65+ ```bash
54 sudo launchctl stop org.nixos.nix-daemon
66 sudo launchctl stop org.nixos.nix-daemon
55 sudo launchctl start org.nixos.nix-daemon
67 sudo launchctl start org.nixos.nix-daemon
56 ```
68 ```
69+1. Install obelisk:
70+ ```bash
57−1. Install obelisk: `nix-env -f https://github.com/obsidiansystems/obelisk/archive/master.tar.gz -iA command`
71+ nix-env -f https://github.com/obsidiansystems/obelisk/archive/master.tar.gz -iA command
58−
59−### Contributing to Obelisk
60−
61−When developing on obelisk itself you may launch `ghcid` for the corresponding project as follows. For example to launch ghcid for `lib/backend` project:
62−
63−```bash
64−nix-shell -A obeliskEnvs.obelisk-backend --run "cd lib/backend && ghcid -c 'cabal new-repl'"
65−```
66−
67−Or to launch ghcid for `lib/command` project:
68−
69−```bash
70−nix-shell -A obeliskEnvs.obelisk-command --run "cd lib/command && ghcid -c 'cabal new-repl'"
71−```
72−
73−To re-install `ob` from source do
74−```bash
75−nix-env -f /path/to/obelisk -iA command
76−```
77−
78−Note that `ob` will defer to the version found in your project's `.obelisk/impl` directory. To update that version specifically:
79−
80−```bash
81−ob thunk unpack ./.obelisk/impl
82−cd ./.obelisk/impl
83−# apply your changes
84−```
85−
86−If you want to commit your changes, first push them to your fork of obelisk and then
87−
88−```bash
89−cd /your/project/root
90−ob thunk pack .obelisk/impl
91−git add .obelisk/impl
92−git commit -m "Bump obelisk"
93−```
72+ ```
94
73
95### Accessing private repositories
74### Accessing private repositories
96
75
@@ -120,119 +99,12 @@ Firefox will not be able to properly run the development website due to [issue 4
120
99
121Every time you change the Haskell source files in frontend, common or backend, `ob run` will automatically recompile the modified files and reload the server. Furthermore, it will display on screen compilation errors and warnings if any.
100Every time you change the Haskell source files in frontend, common or backend, `ob run` will automatically recompile the modified files and reload the server. Furthermore, it will display on screen compilation errors and warnings if any.
122
101
123−### Adding packages
124−
125−In order to add package dependencies, declare them under the build-depends field in the appropriate cabal files (backend, common, and frontend each have their own). The corresponding Nix packages will automatically be selected when building.
126−
127−### Adding package overrides
128−
129−To add a version override to any Haskell package, or to add a Haskell package that doesn't exist in the nixpkgs used by Obelisk, use the `overrides` attribute in your project's `default.nix`. For example, to use a specific version of the `aeson` package fetched from GitHub and a specific version of the `waargonaut` package fetched from Hackage, your `default.nix` will look like:
130−
131−```nix
132−# ...
133−project ./. ({ pkgs, ... }: {
134−# ...
135− overrides = self: super: let
136− aesonSrc = pkgs.fetchFromGitHub {
137− owner = "obsidiansystems";
138− repo = "aeson-gadt-th";
139− rev = "ed573c2cccf54d72aa6279026752a3fecf9c1383";
140− sha256 = "08q6rnz7w9pn76jkrafig6f50yd0f77z48rk2z5iyyl2jbhcbhx3";
141− };
142− in
143− {
144− aeson = self.callCabal2nix "aeson" aesonSrc {};
145− waargonaut = self.callHackageDirect {
146− pkg = "waargonaut";
147− ver = "0.8.0.1";
148− sha256 = "1zv28np3k3hg378vqm89v802xr0g8cwk7gy3mr77xrzy5jbgpa39";
149− } {};
150− };
151−# ...
152−```
153−
154−For further information see [the Haskell section](https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure) of nixpkgs Contributors Guide.
155−
156−### Adding extra local packages
157−
158−If the standard packages (`frontend`, `backend`, and `common`) are not
159−enough, to add more local Haskell packages, define them with the
160−`packages` parameter. The sources of these packages will be
161−automatically reloaded by `ob run`.
162−
163−```nix
164−# ...
165−project ./. ({ pkgs, ... }: {
166−# ...
167− packages = {
168− another = ./another;
169− };
170−# ...
171−```
172−
173−### Running over HTTPS
174−
175−To run your app locally over HTTPS, update the protocol in `config/common/route` to `https`, and then use `ob run` as normal.
176−
177−Since Obelisk generates a self-signed certificate for running HTTPS, the browser will issue a warning about using an invalid certificate. On Chrome, you can go to `chrome://flags/#allow-insecure-localhost` to enable invalid certificates for localhost.
178−
179### IDE Support
102### IDE Support
180
103
181−#### Terminal-based feedback
182−
183Obelisk officially supports terminal-based feedback (akin to [`ghcid`](https://github.com/ndmitchell/ghcid)) in `ob run` and `ob watch`.
104Obelisk officially supports terminal-based feedback (akin to [`ghcid`](https://github.com/ndmitchell/ghcid)) in `ob run` and `ob watch`.
184
105
185−#### **Experimental** `ghcide` support
186−
187−> **NOTE:** `ghcide` support is strictly **experimental** and **not officially supported**. There is no guarantee that it will work for you or that this support will be maintained over time.
188−
189−To try out the **experimental** [`ghcide`](https://github.com/digital-asset/ghcide) support:
190−
191− * Install a `ghcide` plugin for your editor.
192− * Add `__withGhcide = true;` to your Obelisk project's `default.nix` (inside the call to `project`). With this setting, `ob shell` will provide `ghcide` as well.
193− * Add `hie-bios.sh` to the root of your project:
194− ```shell
195− cat > hie-bios.sh <<'EOF'
196− #!/usr/bin/env bash
197− source "$HOME/.bash_profile"; # NOTE: Some editors need help finding 'ob' and this assumes that `ob` is made available on your `$PATH` in `.bash_profile`
198− ob internal export-ghci-configuration > "$HIE_BIOS_OUTPUT"
199− EOF
200− chmod +x hie-bios.sh
201− ```
202− * **Note:** In some projects you need to use `ob internal export-ghci-configuration --use-relative-paths` in this script instead. This is known to happen when your project contains symlinks to other packages.
203− * Add `hie.yaml` to the root of your project:
204− ```shell
205− echo 'cradle: { bios: { program: hie-bios.sh } }' > hie.yaml
206− ```
207− * Test the configuration with `ob shell ghcide`. Assuming your project compiles and works with `ghcide` otherwise, this should succeed.
208− * Start your editor in a way that it can access the appropriate `ghcide`:
209− * This can sometimes be achieved with `ob shell 'start my editor'`.
210− * If you can't easily start your editor in a way that it inherits your shell, you may need to customize how your `ghcide` plugin finds `ghcide` or create a custom `ghcide` replacement script that you install globally. For example, for Visual Studio Code on macOS adding a script called `ghcide` to your `PATH` like the one below will cause `ghcide` from each project's `ob shell` to be used:
211− ```shell
212− #!/usr/bin/env bash
213− source "$HOME/.bash_profile" # NOTE: This assumes that `ob` is made available on your `$PATH` in `.bash_profile`
214− ob shell "ghcide $@"
215− ```
216−
217## Deploying
106## Deploying
218
107
219−### Locally
220−
221−Build everything:
222−
223−```bash
224−nix-build -A exe --no-out-link
225−```
226−
227−Copy the result to a new directory, add configuration, and run!
228−
229−```bash
230−mkdir test-app
231−ln -s $(nix-build -A exe --no-out-link)/* test-app/
232−cp -r config test-app
233−(cd test-app && ./backend)
234−```
235−
236### Default EC2 Deployment
108### Default EC2 Deployment
237
109
238In this section we will demonstrate how to deploy your Obelisk app to an Amazon EC2 instance. Obelisk deployments are configured for EC2 by default (see [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)).
110In this section we will demonstrate how to deploy your Obelisk app to an Amazon EC2 instance. Obelisk deployments are configured for EC2 by default (see [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)).
@@ -242,14 +114,14 @@ First create a new EC2 instance:
2421. Launch a NixOS 19.09 EC2 instance (we recommend [this AMI](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#LaunchInstanceWizard:ami=ami-00a8eeaf232a74f84))
1141. Launch a NixOS 19.09 EC2 instance (we recommend [this AMI](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#LaunchInstanceWizard:ami=ami-00a8eeaf232a74f84))
2431. In the instance configuration wizard ensure that your instance has at least 1GB RAM and 10GB disk space.
1151. In the instance configuration wizard ensure that your instance has at least 1GB RAM and 10GB disk space.
2441. When prompted save your AWS private key (`~/myaws.pem`) somewhere safe. We'll need it later during deployment.
1161. When prompted save your AWS private key (`~/myaws.pem`) somewhere safe. We'll need it later during deployment.
245−1. Go to "Security Groups", select your instance's security group and under "Inbound" tab add a new rule for HTTP port 80 and 443.
117+1. Go to "Security Groups", select your instance's security group and under "Inbound" tab add a new rule for HTTP port 80 and HTTPS port 443.
246
118
247At this stage your instance should be booting and become accessible shortly. Note down the hostname of your EC2 instance.
119At this stage your instance should be booting and become accessible shortly. Note down the hostname of your EC2 instance.
248
120
249Now go to your Obelisk project directory (`~/code/myapp`), and initialize a deployment config (`~/code/myapp-deploy`):
121Now go to your Obelisk project directory (`~/code/myapp`), and initialize a deployment config (`~/code/myapp-deploy`):
250Your project directory must be "thunkable", i.e. something on which `ob thunk pack` can be called. Usually it will be a git repository whose current revision has been pushed upstream.
122Your project directory must be "thunkable", i.e. something on which `ob thunk pack` can be called. Usually it will be a git repository whose current revision has been pushed upstream.
251
123
252−```
124+```bash
253cd ~/code/myapp
125cd ~/code/myapp
254SERVER=ec2-35-183-22-197.ca-central-1.compute.amazonaws.com
126SERVER=ec2-35-183-22-197.ca-central-1.compute.amazonaws.com
255ROUTE=https://myapp.com # Publicly accessible route to your app
127ROUTE=https://myapp.com # Publicly accessible route to your app
@@ -268,7 +140,7 @@ This step will also require that you manually verify the authenticity of the hos
268
140
269Next, go to the deployment directory that you just initialized and deploy!
141Next, go to the deployment directory that you just initialized and deploy!
270
142
271−```
143+```bash
272cd ~/code/myapp-deploy
144cd ~/code/myapp-deploy
273ob deploy push
145ob deploy push
274```
146```
@@ -297,6 +169,25 @@ Here's a `module.nix` that is configured for deployment to a VirtualBox VM (runn
297
169
298The `{...}:` and following is the [NixOS module](https://nixos.org/nixos/manual/index.html#sec-writing-modules) definition.
170The `{...}:` and following is the [NixOS module](https://nixos.org/nixos/manual/index.html#sec-writing-modules) definition.
299
171
172+### Locally
173+
174+If you want deploy your application locally or test a production-oriented build you can build and deploy the app as described below.
175+
176+Build the application:
177+
178+```bash
179+nix-build -A exe --no-out-link
180+```
181+
182+Copy the result to a new directory, add configuration, and run!
183+
184+```bash
185+mkdir test-app
186+ln -s $(nix-build -A exe --no-out-link)/* test-app/
187+cp -r config test-app
188+(cd test-app && ./backend)
189+```
190+
300### From macOS
191### From macOS
301
192
302Deploying from macOS requires some extra setup:
193Deploying from macOS requires some extra setup:
@@ -330,7 +221,7 @@ Your account must also belong to an Apple Developer Team, if you want to access
3301. Click accept to authorize on both the computer and the iPhone.
2211. Click accept to authorize on both the computer and the iPhone.
331
222
332##### Xcode
223##### Xcode
333−Install Xcode 8.2 (contains iOS SDK 10.2) and open it so that it runs its post install tool setup.
224+Install Xcode 11.2 (contains iOS SDK 13.2) and open it so that it runs its post install tool setup.
334
225
335These versions will work out of the box but iOS SDKs prior to 11.3 should also work. You can choose another installed version in `default.nix`
226These versions will work out of the box but iOS SDKs prior to 11.3 should also work. You can choose another installed version in `default.nix`
336
227
@@ -423,3 +314,13 @@ This should copy over and install the application on your device (if you see a
423##### Build a release version
314##### Build a release version
424
315
425After having configured signing for your app, you may proceed to build a release version of the app. This is no different to how you build the non-release version, so consult the section [Android](#android) further above for exact instructions on building and deploying to your device.
316After having configured signing for your app, you may proceed to build a release version of the app. This is no different to how you build the non-release version, so consult the section [Android](#android) further above for exact instructions on building and deploying to your device.
317+
318+
319+## Frequently Asked Questions (FAQ)
320+
321+Refer to [FAQ](FAQ.md).
322+
323+
324+## Contributing
325+
326+Contributions and issue reports are encouraged and appreciated! Refer to the [Contributing](CONTRIBUTING.md) guide for information about getting started.
acme.nixnew file+430
@@ -0,0 +1,430 @@
1+# Copied from https://github.com/NixOS/nixpkgs-channels/blob/70717a337f7ae4e486ba71a500367cad697e5f09/nixos/modules/security/acme.nix # MODIFIED
2+# Lines marked '# MODIFIED' have been added or modified from the original. # MODIFIED
3+{ config, lib, pkgs, ... }:
4+with lib;
5+let
6+
7+ cfg = config.security.acme;
8+
9+ certOpts = { name, ... }: {
10+ options = {
11+ webroot = mkOption {
12+ type = types.nullOr types.str;
13+ default = null;
14+ example = "/var/lib/acme/acme-challenges";
15+ description = ''
16+ Where the webroot of the HTTP vhost is located.
17+ <filename>.well-known/acme-challenge/</filename> directory
18+ will be created below the webroot if it doesn't exist.
19+ <literal>http://example.org/.well-known/acme-challenge/</literal> must also
20+ be available (notice unencrypted HTTP).
21+ '';
22+ };
23+
24+ server = mkOption {
25+ type = types.nullOr types.str;
26+ default = null;
27+ description = ''
28+ ACME Directory Resource URI. Defaults to let's encrypt
29+ production endpoint,
30+ https://acme-v02.api.letsencrypt.org/directory, if unset.
31+ '';
32+ };
33+
34+ domain = mkOption {
35+ type = types.str;
36+ default = name;
37+ description = "Domain to fetch certificate for (defaults to the entry name)";
38+ };
39+
40+ email = mkOption {
41+ type = types.nullOr types.str;
42+ default = cfg.email;
43+ description = "Contact email address for the CA to be able to reach you.";
44+ };
45+
46+ user = mkOption {
47+ type = types.str;
48+ default = "root";
49+ description = "User running the ACME client.";
50+ };
51+
52+ group = mkOption {
53+ type = types.str;
54+ default = "root";
55+ description = "Group running the ACME client.";
56+ };
57+
58+ allowKeysForGroup = mkOption {
59+ type = types.bool;
60+ default = false;
61+ description = ''
62+ Give read permissions to the specified group
63+ (<option>security.acme.cert.&lt;name&gt;.group</option>) to read SSL private certificates.
64+ '';
65+ };
66+
67+ postRun = mkOption {
68+ type = types.lines;
69+ default = "";
70+ example = "systemctl reload nginx.service";
71+ description = ''
72+ Commands to run after new certificates go live. Typically
73+ the web server and other servers using certificates need to
74+ be reloaded.
75+ Executed in the same directory with the new certificate.
76+ '';
77+ };
78+
79+ directory = mkOption {
80+ type = types.str;
81+ readOnly = true;
82+ default = "/var/lib/acme/${name}";
83+ description = "Directory where certificate and other state is stored.";
84+ };
85+
86+ extraDomains = mkOption {
87+ type = types.attrsOf (types.nullOr types.str);
88+ default = {};
89+ example = literalExample ''
90+ {
91+ "example.org" = null;
92+ "mydomain.org" = null;
93+ }
94+ '';
95+ description = ''
96+ A list of extra domain names, which are included in the one certificate to be issued.
97+ Setting a distinct server root is deprecated and not functional in 20.03+
98+ '';
99+ };
100+
101+ keyType = mkOption {
102+ type = types.str;
103+ default = "ec256";
104+ description = ''
105+ Key type to use for private keys.
106+ For an up to date list of supported values check the --key-type option
107+ at https://go-acme.github.io/lego/usage/cli/#usage.
108+ '';
109+ };
110+
111+ dnsProvider = mkOption {
112+ type = types.nullOr types.str;
113+ default = null;
114+ example = "route53";
115+ description = ''
116+ DNS Challenge provider. For a list of supported providers, see the "code"
117+ field of the DNS providers listed at https://go-acme.github.io/lego/dns/.
118+ '';
119+ };
120+
121+ credentialsFile = mkOption {
122+ type = types.path;
123+ description = ''
124+ Path to an EnvironmentFile for the cert's service containing any required and
125+ optional environment variables for your selected dnsProvider.
126+ To find out what values you need to set, consult the documentation at
127+ https://go-acme.github.io/lego/dns/ for the corresponding dnsProvider.
128+ '';
129+ example = "/var/src/secrets/example.org-route53-api-token";
130+ };
131+
132+ dnsPropagationCheck = mkOption {
133+ type = types.bool;
134+ default = true;
135+ description = ''
136+ Toggles lego DNS propagation check, which is used alongside DNS-01
137+ challenge to ensure the DNS entries required are available.
138+ '';
139+ };
140+ };
141+ };
142+
143+in
144+
145+{
146+
147+ ###### interface
148+ imports = [
149+ (mkRemovedOptionModule [ "security" "acme" "production" ] ''
150+ Use security.acme.server to define your staging ACME server URL instead.
151+ To use the let's encrypt staging server, use security.acme.server =
152+ "https://acme-staging-v02.api.letsencrypt.org/directory".
153+ ''
154+ )
155+ # (mkRemovedOptionModule [ "security" "acme" "directory"] "ACME Directory is now hardcoded to /var/lib/acme and its permisisons are managed by systemd. See https://github.com/NixOS/nixpkgs/issues/53852 for more info.") # MODIFIED
156+ # (mkRemovedOptionModule [ "security" "acme" "preDelay"] "This option has been removed. If you want to make sure that something executes before certificates are provisioned, add a RequiredBy=acme-\${cert}.service to the service you want to execute before the cert renewal") # MODIFIED
157+ # (mkRemovedOptionModule [ "security" "acme" "activationDelay"] "This option has been removed. If you want to make sure that something executes before certificates are provisioned, add a RequiredBy=acme-\${cert}.service to the service you want to execute before the cert renewal") # MODIFIED
158+ (mkChangedOptionModule [ "security" "acme" "validMin"] [ "security" "acme" "validMinDays"] (config: config.security.acme.validMin / (24 * 3600)))
159+ ];
160+ options = {
161+ security.acme = {
162+
163+ validMinDays = mkOption {
164+ type = types.int;
165+ default = 30;
166+ description = "Minimum remaining validity before renewal in days.";
167+ };
168+
169+ email = mkOption {
170+ type = types.nullOr types.str;
171+ default = null;
172+ description = "Contact email address for the CA to be able to reach you.";
173+ };
174+
175+ renewInterval = mkOption {
176+ type = types.str;
177+ default = "daily";
178+ description = ''
179+ Systemd calendar expression when to check for renewal. See
180+ <citerefentry><refentrytitle>systemd.time</refentrytitle>
181+ <manvolnum>7</manvolnum></citerefentry>.
182+ '';
183+ };
184+
185+ server = mkOption {
186+ type = types.nullOr types.str;
187+ default = null;
188+ description = ''
189+ ACME Directory Resource URI. Defaults to let's encrypt
190+ production endpoint,
191+ <literal>https://acme-v02.api.letsencrypt.org/directory</literal>, if unset.
192+ '';
193+ };
194+
195+ preliminarySelfsigned = mkOption {
196+ type = types.bool;
197+ default = true;
198+ description = ''
199+ Whether a preliminary self-signed certificate should be generated before
200+ doing ACME requests. This can be useful when certificates are required in
201+ a webserver, but ACME needs the webserver to make its requests.
202+ With preliminary self-signed certificate the webserver can be started and
203+ can later reload the correct ACME certificates.
204+ '';
205+ };
206+
207+ acceptTerms = mkOption {
208+ type = types.bool;
209+ default = false;
210+ description = ''
211+ Accept the CA's terms of service. The default provier is Let's Encrypt,
212+ you can find their ToS at https://letsencrypt.org/repository/
213+ '';
214+ };
215+
216+ certs = mkOption {
217+ default = { };
218+ type = with types; attrsOf (submodule certOpts);
219+ description = ''
220+ Attribute set of certificates to get signed and renewed. Creates
221+ <literal>acme-''${cert}.{service,timer}</literal> systemd units for
222+ each certificate defined here. Other services can add dependencies
223+ to those units if they rely on the certificates being present,
224+ or trigger restarts of the service if certificates get renewed.
225+ '';
226+ example = literalExample ''
227+ {
228+ "example.com" = {
229+ webroot = "/var/www/challenges/";
230+ email = "foo@example.com";
231+ extraDomains = { "www.example.com" = null; "foo.example.com" = null; };
232+ };
233+ "bar.example.com" = {
234+ webroot = "/var/www/challenges/";
235+ email = "bar@example.com";
236+ };
237+ }
238+ '';
239+ };
240+ };
241+ };
242+
243+ ###### implementation
244+ config = mkMerge [
245+ (mkIf (cfg.certs != { }) {
246+
247+ assertions = let
248+ certs = (mapAttrsToList (k: v: v) cfg.certs);
249+ in [
250+ {
251+ assertion = all (certOpts: certOpts.dnsProvider == null || certOpts.webroot == null) certs;
252+ message = ''
253+ Options `security.acme.certs.<name>.dnsProvider` and
254+ `security.acme.certs.<name>.webroot` are mutually exclusive.
255+ '';
256+ }
257+ {
258+ assertion = cfg.email != null || all (certOpts: certOpts.email != null) certs;
259+ message = ''
260+ You must define `security.acme.certs.<name>.email` or
261+ `security.acme.email` to register with the CA.
262+ '';
263+ }
264+ {
265+ assertion = cfg.acceptTerms;
266+ message = ''
267+ You must accept the CA's terms of service before using
268+ the ACME module by setting `security.acme.acceptTerms`
269+ to `true`. For Let's Encrypt's ToS see https://letsencrypt.org/repository/
270+ '';
271+ }
272+ ];
273+
274+ systemd.services = let
275+ services = concatLists servicesLists;
276+ servicesLists = mapAttrsToList certToServices cfg.certs;
277+ certToServices = cert: data:
278+ let
279+ # StateDirectory must be relative, and will be created under /var/lib by systemd
280+ lpath = "acme/${cert}";
281+ apath = "/var/lib/${lpath}";
282+ spath = "/var/lib/acme/.lego/${cert}";
283+ fileMode = if data.allowKeysForGroup then "640" else "600";
284+ globalOpts = [ "-d" data.domain "--email" data.email "--path" "." "--key-type" data.keyType ]
285+ ++ optionals (cfg.acceptTerms) [ "--accept-tos" ]
286+ ++ optionals (data.dnsProvider != null && !data.dnsPropagationCheck) [ "--dns.disable-cp" ]
287+ ++ concatLists (mapAttrsToList (name: root: [ "-d" name ]) data.extraDomains)
288+ ++ (if data.dnsProvider != null then [ "--dns" data.dnsProvider ] else [ "--http" "--http.webroot" data.webroot ])
289+ ++ optionals (cfg.server != null || data.server != null) ["--server" (if data.server == null then cfg.server else data.server)];
290+ runOpts = escapeShellArgs (globalOpts ++ [ "run" ]);
291+ renewOpts = escapeShellArgs (globalOpts ++ [ "renew" "--days" (toString cfg.validMinDays) ]);
292+ acmeService = {
293+ description = "Renew ACME Certificate for ${cert}";
294+ after = [ "network.target" "network-online.target" ];
295+ wants = [ "network-online.target" ];
296+ wantedBy = mkIf (!config.boot.isContainer) [ "multi-user.target" ];
297+ serviceConfig = {
298+ Type = "oneshot";
299+ User = data.user;
300+ Group = data.group;
301+ PrivateTmp = true;
302+ StateDirectory = "acme/.lego/${cert} acme/.lego/accounts ${lpath}";
303+ StateDirectoryMode = if data.allowKeysForGroup then "750" else "700";
304+ WorkingDirectory = spath;
305+ # Only try loading the credentialsFile if the dns challenge is enabled
306+ EnvironmentFile = if data.dnsProvider != null then data.credentialsFile else null;
307+ ExecStart = pkgs.writeScript "acme-start" ''
308+ #!${pkgs.runtimeShell} -e
309+ test -L ${spath}/accounts -o -d ${spath}/accounts || ln -s ../accounts ${spath}/accounts
310+ ${pkgs.lego}/bin/lego ${renewOpts} || ${pkgs.lego}/bin/lego ${runOpts}
311+ '';
312+ ExecStartPost =
313+ let
314+ keyName = builtins.replaceStrings ["*"] ["_"] data.domain;
315+ script = pkgs.writeScript "acme-post-start" ''
316+ #!${pkgs.runtimeShell} -e
317+ cd ${apath}
318+ # Test that existing cert is older than new cert
319+ KEY=${spath}/certificates/${keyName}.key
320+ KEY_CHANGED=no
321+ if [ -e $KEY -a $KEY -nt key.pem ]; then
322+ KEY_CHANGED=yes
323+ cp -p ${spath}/certificates/${keyName}.key key.pem
324+ cp -p ${spath}/certificates/${keyName}.crt fullchain.pem
325+ cp -p ${spath}/certificates/${keyName}.issuer.crt chain.pem
326+ ln -sf fullchain.pem cert.pem
327+ cat key.pem fullchain.pem > full.pem
328+ fi
329+ chmod ${fileMode} *.pem
330+ chown '${data.user}:${data.group}' *.pem
331+ if [ "$KEY_CHANGED" = "yes" ]; then
332+ : # noop in case postRun is empty
333+ ${data.postRun}
334+ fi
335+ '';
336+ in
337+ "+${script}";
338+ };
339+
340+ };
341+ selfsignedService = {
342+ description = "Create preliminary self-signed certificate for ${cert}";
343+ path = [ pkgs.openssl ];
344+ script =
345+ ''
346+ workdir="$(mktemp -d)"
347+ # Create CA
348+ openssl genrsa -des3 -passout pass:xxxx -out $workdir/ca.pass.key 2048
349+ openssl rsa -passin pass:xxxx -in $workdir/ca.pass.key -out $workdir/ca.key
350+ openssl req -new -key $workdir/ca.key -out $workdir/ca.csr \
351+ -subj "/C=UK/ST=Warwickshire/L=Leamington/O=OrgName/OU=Security Department/CN=example.com"
352+ openssl x509 -req -days 1 -in $workdir/ca.csr -signkey $workdir/ca.key -out $workdir/ca.crt
353+ # Create key
354+ openssl genrsa -des3 -passout pass:xxxx -out $workdir/server.pass.key 2048
355+ openssl rsa -passin pass:xxxx -in $workdir/server.pass.key -out $workdir/server.key
356+ openssl req -new -key $workdir/server.key -out $workdir/server.csr \
357+ -subj "/C=UK/ST=Warwickshire/L=Leamington/O=OrgName/OU=IT Department/CN=example.com"
358+ openssl x509 -req -days 1 -in $workdir/server.csr -CA $workdir/ca.crt \
359+ -CAkey $workdir/ca.key -CAserial $workdir/ca.srl -CAcreateserial \
360+ -out $workdir/server.crt
361+ # Copy key to destination
362+ cp $workdir/server.key ${apath}/key.pem
363+ # Create fullchain.pem (same format as "simp_le ... -f fullchain.pem" creates)
364+ cat $workdir/{server.crt,ca.crt} > "${apath}/fullchain.pem"
365+ # Create full.pem for e.g. lighttpd
366+ cat $workdir/{server.key,server.crt,ca.crt} > "${apath}/full.pem"
367+ # Give key acme permissions
368+ chown '${data.user}:${data.group}' "${apath}/"{key,fullchain,full}.pem
369+ chmod ${fileMode} "${apath}/"{key,fullchain,full}.pem
370+ '';
371+ serviceConfig = {
372+ Type = "oneshot";
373+ PrivateTmp = true;
374+ StateDirectory = lpath;
375+ User = data.user;
376+ Group = data.group;
377+ };
378+ unitConfig = {
379+ # Do not create self-signed key when key already exists
380+ ConditionPathExists = "!${apath}/key.pem";
381+ };
382+ };
383+ in (
384+ [ { name = "acme-${cert}"; value = acmeService; } ]
385+ ++ optional cfg.preliminarySelfsigned { name = "acme-selfsigned-${cert}"; value = selfsignedService; }
386+ );
387+ servicesAttr = listToAttrs services;
388+ in
389+ servicesAttr;
390+
391+ systemd.tmpfiles.rules =
392+ map (data: "d ${data.webroot}/.well-known/acme-challenge - ${data.user} ${data.group}") (filter (data: data.webroot != null) (attrValues cfg.certs));
393+
394+ systemd.timers = let
395+ # Allow systemd to pick a convenient time within the day
396+ # to run the check.
397+ # This allows the coalescing of multiple timer jobs.
398+ # We divide by the number of certificates so that if you
399+ # have many certificates, the renewals are distributed over
400+ # the course of the day to avoid rate limits.
401+ numCerts = length (attrNames cfg.certs);
402+ _24hSecs = 60 * 60 * 24;
403+ AccuracySec = "${toString (_24hSecs / numCerts)}s";
404+ in flip mapAttrs' cfg.certs (cert: data: nameValuePair
405+ ("acme-${cert}")
406+ ({
407+ description = "Renew ACME Certificate for ${cert}";
408+ wantedBy = [ "timers.target" ];
409+ timerConfig = {
410+ OnCalendar = cfg.renewInterval;
411+ Unit = "acme-${cert}.service";
412+ Persistent = "yes";
413+ inherit AccuracySec;
414+ # Skew randomly within the day, per https://letsencrypt.org/docs/integration-guide/.
415+ RandomizedDelaySec = "24h";
416+ };
417+ })
418+ );
419+
420+ systemd.targets.acme-selfsigned-certificates = mkIf cfg.preliminarySelfsigned {};
421+ systemd.targets.acme-certificates = {};
422+ })
423+
424+ ];
425+
426+ meta = {
427+ maintainers = with lib.maintainers; [ abbradar fpletz globin m1cr0man ];
428+ # doc = ./acme.xml; # MODIFIED
429+ };
430+}
all-builds.nix+1−1
@@ -1,6 +1,6 @@
1{ self-args ? {
1{ self-args ? {
2 config.android_sdk.accept_license = true;
2 config.android_sdk.accept_license = true;
3− iosSdkVersion = "10.2";
3+ iosSdkVersion = "13.2";
4 }
4 }
5, local-self ? import ./. self-args
5, local-self ? import ./. self-args
6, supportedSystems ? [ builtins.currentSystem ]
6, supportedSystems ? [ builtins.currentSystem ]
default.nix+60−27
@@ -1,7 +1,10 @@
1{ system ? builtins.currentSystem
1{ system ? builtins.currentSystem
2, profiling ? false
2, profiling ? false
3−, iosSdkVersion ? "10.2"
3+, iosSdkVersion ? "13.2"
4, config ? {}
4, config ? {}
5+, terms ? { # Accepted terms, conditions, and licenses
6+ security.acme.acceptTerms = false;
7+ }
5, reflex-platform-func ? import ./dep/reflex-platform
8, reflex-platform-func ? import ./dep/reflex-platform
6}:
9}:
7let
10let
@@ -43,7 +46,7 @@ in rec {
43 pathGit = ./.; # Used in CI by the migration graph hash algorithm to correctly ignore files.
46 pathGit = ./.; # Used in CI by the migration graph hash algorithm to correctly ignore files.
44 path = reflex-platform.filterGit ./.;
47 path = reflex-platform.filterGit ./.;
45 obelisk = ghcObelisk;
48 obelisk = ghcObelisk;
46− obeliskEnvs = pkgs.lib.filterAttrs (k: _: pkgs.lib.strings.hasPrefix "obelisk-" k) ghcObeliskEnvs;
49+ obeliskEnvs = pkgs.lib.filterAttrs (k: _: k == "tabulation" || pkgs.lib.strings.hasPrefix "obelisk-" k) ghcObeliskEnvs; #TODO: use thunkSet https://github.com/reflex-frp/reflex-platform/pull/671
47 command = ghcObelisk.obelisk-command;
50 command = ghcObelisk.obelisk-command;
48 shell = pinBuildInputs "obelisk-shell" ([command] ++ command.commandRuntimeDeps);
51 shell = pinBuildInputs "obelisk-shell" ([command] ++ command.commandRuntimeDeps);
49
52
@@ -74,16 +77,20 @@ in rec {
74 '';
77 '';
75
78
76 compressedJs = frontend: optimizationLevel: pkgs.runCommand "compressedJs" {} ''
79 compressedJs = frontend: optimizationLevel: pkgs.runCommand "compressedJs" {} ''
77− mkdir $out
80+ set -euo pipefail
78− cd $out
79− # TODO profiling + static shouldn't break and need an ad-hoc workaround like that
80− ln -s "${haskellLib.justStaticExecutables frontend}/bin/frontend.jsexe/all.js" all.unminified.js
81+ cd '${haskellLib.justStaticExecutables frontend}'
82+ shopt -s globstar
83+ for f in **/all.js; do
84+ dir="$out/$(basename "$(dirname "$f")")"
85+ mkdir -p "$dir"
86+ ln -s "$(realpath "$f")" "$dir/all.unminified.js"
81− ${if optimizationLevel == null then ''
87+ ${if optimizationLevel == null then ''
82− ln -s all.unminified.js all.js
88+ ln -s "$dir/all.unminified.js" "$dir/all.js"
83− '' else ''
89+ '' else ''
84− ${pkgs.closurecompiler}/bin/closure-compiler --externs "${reflex-platform.ghcjsExternsJs}" -O ${optimizationLevel} --jscomp_warning=checkVars --create_source_map="all.js.map" --source_map_format=V3 --js_output_file="all.js" all.unminified.js
90+ '${pkgs.closurecompiler}/bin/closure-compiler' --externs '${reflex-platform.ghcjsExternsJs}' -O '${optimizationLevel}' --jscomp_warning=checkVars --create_source_map="$dir/all.js.map" --source_map_format=V3 --js_output_file="$dir/all.js" "$dir/all.unminified.js"
85− echo "//# sourceMappingURL=all.js.map" >> all.js
91+ echo '//# sourceMappingURL=all.js.map' >> "$dir/all.js"
86− ''}
92+ ''}
93+ done
87 '';
94 '';
88
95
89 serverModules = {
96 serverModules = {
@@ -109,6 +116,8 @@ in rec {
109 security.acme.certs = if enableHttps then {
116 security.acme.certs = if enableHttps then {
110 "${routeHost}".email = adminEmail;
117 "${routeHost}".email = adminEmail;
111 } else {};
118 } else {};
119+
120+ security.acme.${if enableHttps && (terms.security.acme.acceptTerms or false) then "acceptTerms" else null} = true;
112 };
121 };
113
122
114 mkObeliskApp =
123 mkObeliskApp =
@@ -125,12 +134,16 @@ in rec {
125 }: {...}: {
134 }: {...}: {
126 services.nginx = {
135 services.nginx = {
127 enable = true;
136 enable = true;
137+ recommendedProxySettings = true;
128 virtualHosts."${routeHost}" = {
138 virtualHosts."${routeHost}" = {
129 enableACME = enableHttps;
139 enableACME = enableHttps;
130 forceSSL = enableHttps;
140 forceSSL = enableHttps;
131 locations.${baseUrl} = {
141 locations.${baseUrl} = {
132 proxyPass = "http://127.0.0.1:" + toString internalPort;
142 proxyPass = "http://127.0.0.1:" + toString internalPort;
133 proxyWebsockets = true;
143 proxyWebsockets = true;
144+ extraConfig = ''
145+ access_log off;
146+ '';
134 };
147 };
135 };
148 };
136 };
149 };
@@ -171,9 +184,11 @@ in rec {
171 pkgs.runCommand "serverExe" {} ''
184 pkgs.runCommand "serverExe" {} ''
172 mkdir $out
185 mkdir $out
173 set -eux
186 set -eux
174− ln -s "${if profiling then backend else haskellLib.justStaticExecutables backend}"/bin/* $out/
187+ ln -s '${if profiling then backend else haskellLib.justStaticExecutables backend}'/bin/* $out/
175− ln -s "${mkAssets assets}" $out/static.assets
188+ ln -s '${mkAssets assets}' $out/static.assets
176− ln -s ${mkAssets (compressedJs frontend optimizationLevel)} $out/frontend.jsexe.assets
189+ for d in '${mkAssets (compressedJs frontend optimizationLevel)}'/*/; do
190+ ln -s "$d" "$out"/"$(basename "$d").assets"
191+ done
177 echo ${version} > $out/version
192 echo ${version} > $out/version
178 '';
193 '';
179
194
@@ -187,6 +202,20 @@ in rec {
187 (module { inherit exe hostName adminEmail routeHost enableHttps version; nixosPkgs = pkgs; })
202 (module { inherit exe hostName adminEmail routeHost enableHttps version; nixosPkgs = pkgs; })
188 (serverModules.mkDefaultNetworking args)
203 (serverModules.mkDefaultNetworking args)
189 (serverModules.mkObeliskApp args)
204 (serverModules.mkObeliskApp args)
205+ ./acme.nix # Backport of ACME upgrades from 20.03
206+ ];
207+
208+ # Backport of ACME upgrades from 20.03
209+ disabledModules = [
210+ (pkgs.path + /nixos/modules/security/acme.nix)
211+ ];
212+ nixpkgs.overlays = [
213+ (self: super: {
214+ lego = (import (builtins.fetchTarball {
215+ url = https://github.com/NixOS/nixpkgs-channels/archive/70717a337f7ae4e486ba71a500367cad697e5f09.tar.gz;
216+ sha256 = "1sbmqn7yc5iilqnvy9nvhsa9bx6spfq1kndvvis9031723iyymd1";
217+ }) {}).lego;
218+ })
190 ];
219 ];
191 };
220 };
192 };
221 };
@@ -321,29 +350,33 @@ in rec {
321 __unstable__.profiledObRun = let
350 __unstable__.profiledObRun = let
322 profiled = projectOut { inherit system; enableLibraryProfiling = true; };
351 profiled = projectOut { inherit system; enableLibraryProfiling = true; };
323 exeSource = builtins.toFile "ob-run.hs" ''
352 exeSource = builtins.toFile "ob-run.hs" ''
353+ {-# LANGUAGE NoImplicitPrelude #-}
354+ {-# LANGUAGE PackageImports #-}
324 module Main where
355 module Main where
325
356
357+ -- Explicitly import Prelude from base lest there be multiple modules called Prelude
358+ import "base" Prelude (IO, (++), read)
359+
326− import Control.Exception
360+ import "base" Control.Exception (finally)
327− import Reflex.Profiled
361+ import "reflex" Reflex.Profiled (writeProfilingData)
328− import System.Environment
362+ import "base" System.Environment (getArgs)
329
363
330− import qualified Obelisk.Run
364+ import qualified "obelisk-run" Obelisk.Run
331 import qualified Frontend
365 import qualified Frontend
332 import qualified Backend
366 import qualified Backend
333
367
334 main :: IO ()
368 main :: IO ()
335 main = do
369 main = do
336− args <- getArgs
370+ [portStr, assets, profFileName] <- getArgs
337− let port = read $ args !! 0
338− assets = args !! 1
339− profileFile = (args !! 2) <> ".rprof"
340− Obelisk.Run.run port (Obelisk.Run.runServeAsset assets) Backend.backend Frontend.frontend `finally` writeProfilingData profileFile
371+ Obelisk.Run.run (read portStr) (Obelisk.Run.runServeAsset assets) Backend.backend Frontend.frontend
372+ `finally` writeProfilingData (profFileName ++ ".rprof")
341 '';
373 '';
342 in nixpkgs.runCommand "ob-run" {
374 in nixpkgs.runCommand "ob-run" {
343− buildInputs = [ (profiled.ghc.ghcWithPackages (p: [ p.backend p.frontend])) ];
375+ buildInputs = [ (profiled.ghc.ghcWithPackages (p: [p.backend p.frontend])) ];
344 } ''
376 } ''
377+ cp ${exeSource} ob-run.hs
345− mkdir -p $out/bin/
378+ mkdir -p $out/bin
346− ghc -x hs -prof -fno-prof-auto -threaded ${exeSource} -o $out/bin/ob-run
379+ ghc -x hs -prof -fno-prof-auto -threaded ob-run.hs -o $out/bin/ob-run
347 '';
380 '';
348
381
349 linuxExeConfigurable = linuxExe;
382 linuxExeConfigurable = linuxExe;
dep/reflex-platform/default.nix+1−7
@@ -1,8 +1,2 @@
1# DO NOT HAND-EDIT THIS FILE
1# DO NOT HAND-EDIT THIS FILE
2−let fetch = { private ? false, fetchSubmodules ? false, owner, repo, rev, sha256, ... }:
2+import (import ./thunk.nix)
3− if !fetchSubmodules && !private then builtins.fetchTarball {
4− url = "https://github.com/${owner}/${repo}/archive/${rev}.tar.gz"; inherit sha256;
5− } else (import <nixpkgs> {}).fetchFromGitHub {
6− inherit owner repo rev sha256 fetchSubmodules private;
7− };
8−in import (fetch (builtins.fromJSON (builtins.readFile ./github.json)))
dep/reflex-platform/github.json+3−3
@@ -1,8 +1,8 @@
1{
1{
2 "owner": "reflex-frp",
2 "owner": "reflex-frp",
3 "repo": "reflex-platform",
3 "repo": "reflex-platform",
4− "branch": "release/0.5.3.0",
4+ "branch": "release/0.7.0.0",
5 "private": false,
5 "private": false,
6− "rev": "9779ea3b4c87fdc971057c561262696d5e9b1847",
6+ "rev": "27a7851a780ff21472d85f9a02fb84635ef9027a",
7− "sha256": "0v87ilal9355xwz8y9m0zh14pm9c0f7pqch0854kkj92ybc5l62q"
7+ "sha256": "1m4zlw91dpjlbdchjyxhvhv3k7lilm0qa17dhhww868xxc27sann"
8}
8}
dep/reflex-platform/thunk.nixnew file+9
@@ -0,0 +1,9 @@
1+# DO NOT HAND-EDIT THIS FILE
2+let fetch = { private ? false, fetchSubmodules ? false, owner, repo, rev, sha256, ... }:
3+ if !fetchSubmodules && !private then builtins.fetchTarball {
4+ url = "https://github.com/${owner}/${repo}/archive/${rev}.tar.gz"; inherit sha256;
5+ } else (import <nixpkgs> {}).fetchFromGitHub {
6+ inherit owner repo rev sha256 fetchSubmodules private;
7+ };
8+ json = builtins.fromJSON (builtins.readFile ./github.json);
9+in fetch json
docs/obelisk-logo-640.pngnew file

Binary file not shown.

guides/app-deploy/README.md+16−10
@@ -1,13 +1,14 @@
1# Obelisk Application Deployment Guide
1# Obelisk Application Deployment Guide
2+
2This document serves two purposes, the first one is to guide new users that want to deploy Obelisk/Reflex apps and the second one to provide a walk-through for test driving Obelisk releases.
3This document serves two purposes, the first one is to guide new users that want to deploy Obelisk/Reflex apps and the second one to provide a walk-through for test driving Obelisk releases.
3
4
4−> **Note:** To complete this *entire* guide you need access to a macOS machine running the latest OSX release, a Linux machine (can be a VM on that mac) with Nix installed, an iPhone or iPad, and a recent Android device. It also assumes that you have Nix correctly set up and that your system is set up to fetch from binary caches instead of building everything on your machine. If you notice any of the commands below takes more than 5 minutes, then caches are not likely enabled.
5+> **Note:** This guide can be completed on a Linux host with Nix installed or a macOS host with Nix installed. Each section is labeled regarding which operating system hosts it supports. When going through the guide, start at the beginning and go through all sections that are supported on your host and merely skip sections that are not supported. The sections for iOS deployments require an iPhone or iPad device and the sections for Android deployments require an Android device. This guide assumes that you have Nix correctly set up and that your system is configured to fetch from binary caches instead of building everything on your machine. If you notice any of the commands below takes more than 5 minutes, then caches are not likely enabled.
5>
6>
6> Refer to the [Obelisk Installation Documentation](https://github.com/obsidiansystems/obelisk#installing-obelisk) for instructions on configuring the binary caches for any Nix-compatible setup.
7> Refer to the [Obelisk Installation Documentation](https://github.com/obsidiansystems/obelisk#installing-obelisk) for instructions on configuring the binary caches for any Nix-compatible setup.
7
8
8−## a) Get Obelisk
9+## a) Get Obelisk (Linux, Mac)
9
10
10−There are several ways to install Obelisk, but the one we are going to use here allows us to test a single version of Obelisk in different ways. The approach is to clone Obelisk from it's GitHub repository and start a project that uses that local check out.
11+There are several ways to install Obelisk, but the one we are going to use here allows us to test a single version of Obelisk in different ways. The approach is to clone Obelisk from its GitHub repository and start a project that uses that local check out.
11
12
12Open a terminal and run the following:
13Open a terminal and run the following:
13
14
@@ -39,7 +40,7 @@ ob init --branch "$OBELISK_BRANCH"
39
40
40> **Note:** If the `--branch` parameter is not used, then Obelisk sets your project up to look at the `master` branch from GitHub. This is quite handy for real life projects but distracting for our test drive since we want to make sure any changes we do to the Obelisk codebase (like testing a pull request) are immediately picked up.
41> **Note:** If the `--branch` parameter is not used, then Obelisk sets your project up to look at the `master` branch from GitHub. This is quite handy for real life projects but distracting for our test drive since we want to make sure any changes we do to the Obelisk codebase (like testing a pull request) are immediately picked up.
41
42
42−## b) Run the Obelisk app on localhost
43+## b) Run the Obelisk app on localhost (Linux, Mac)
43
44
44Let's test that we can run a server on localhost. This is quite easy:
45Let's test that we can run a server on localhost. This is quite easy:
45
46
@@ -52,9 +53,10 @@ Now open a browser and point it to http://localhost:8000 (or just click on this
52
53
53![](assets/app-deploy.png)
54![](assets/app-deploy.png)
54
55
55−## c) Deploy the web app on a remote machine
56+## c) Prepare a VirtualBox deploy target (Linux, Mac)
56
57
57### Import the NixOS VirtualBox appliance
58### Import the NixOS VirtualBox appliance
59+
58Install [VirtualBox](https://www.virtualbox.org/) on your machine.
60Install [VirtualBox](https://www.virtualbox.org/) on your machine.
59
61
60On NixOS, do this by adding the following line to your `/etc/nixos/configuration.nix` before the last line containing `}`:
62On NixOS, do this by adding the following line to your `/etc/nixos/configuration.nix` before the last line containing `}`:
@@ -79,7 +81,7 @@ You should now see a NixOS machine in the dashboard:
79
81
80![](assets/virtualbox-dashboard-nixos.png)
82![](assets/virtualbox-dashboard-nixos.png)
81
83
82−If you are on a network with DHCP on your wireless or network card then select right-click on the "NixOS" image and click "Settings". Go to the "Network" section and make "Attached to:" set to "Bridged Adapter".
84+If you are on a network with DHCP on your wireless or network card then right-click on the "NixOS" image and click "Settings". Go to the "Network" section and make "Attached to:" set to "Bridged Adapter".
83
85
84![](assets/virtualbox-image-settings-network.png)
86![](assets/virtualbox-image-settings-network.png)
85
87
@@ -201,7 +203,7 @@ git remote add origin "$WORKDIR/myapp-git-remote"
201git push -u origin master
203git push -u origin master
202```
204```
203
205
204−### Deploy
206+### Initialize deployment directory
205
207
206With that, we can come back to the Obelisk app and initialize the deployment:
208With that, we can come back to the Obelisk app and initialize the deployment:
207
209
@@ -216,7 +218,11 @@ Then configure the deployment for VirtualBox:
216echo '{nixosPkgs, ...}: {...}: { imports = [ (nixosPkgs.path + /nixos/modules/virtualisation/virtualbox-image.nix) ]; }' > "$WORKDIR/myappdeploy/module.nix"
218echo '{nixosPkgs, ...}: {...}: { imports = [ (nixosPkgs.path + /nixos/modules/virtualisation/virtualbox-image.nix) ]; }' > "$WORKDIR/myappdeploy/module.nix"
217```
219```
218
220
219−And deploy:
221+## d) Deploy to VirtualBox target (Linux only)
222+
223+> Deploying requires a Linux host in order to build the Linux binaries.
224+
225+Now we can deploy to the VirtualBox VM.
220
226
221```bash
227```bash
222cd "$WORKDIR/myappdeploy"
228cd "$WORKDIR/myappdeploy"
@@ -243,7 +249,7 @@ It should look like this:
243
249
244Congratulations! You have deployed an Obelisk application to a remote server via SSH.
250Congratulations! You have deployed an Obelisk application to a remote server via SSH.
245
251
246−## d) Deploy an Android app (Linux host only)
252+## e) Deploy an Android app (Linux only)
247
253
248> **Note:** This section requires that you be running a Linux *host*.
254> **Note:** This section requires that you be running a Linux *host*.
249
255
@@ -286,7 +292,7 @@ When the deployment is complete opening the app should look something like
286
292
287Congratulations! You have deployed an Obelisk Android app via USB.
293Congratulations! You have deployed an Obelisk Android app via USB.
288
294
289−## e) Deploy an iOS app (macOS host only)
295+## f) Deploy an iOS app (Mac only)
290
296
291> **Note:** This section requires that you be running a macOS *host*.
297> **Note:** This section requires that you be running a macOS *host*.
292
298
haskell-overlays/ghcide.nix+38−32
@@ -1,34 +1,40 @@
1self: super:
1self: super:
2− let
2+let
3− pkgs = self.callPackage ({ pkgs }: pkgs) {};
3+ pkgs = self.callPackage ({ pkgs }: pkgs) { };
4− inherit (pkgs.haskell.lib) dontCheck;
4+ inherit (pkgs.haskell.lib) dontCheck justStaticExecutables;
5+ inherit (pkgs.haskellPackages) callHackageDirect callHackage;
6+
5− in {
7+in {
6− ghcide = pkgs.haskell.lib.justStaticExecutables (dontCheck ((self.override {
8+ ghcide = justStaticExecutables (dontCheck (callHackageDirect {
7− overrides = self: super: {
9+ pkg = "ghcide";
10+ ver = "0.2.0";
11+ sha256 = "199l4qzrghhz6wbfkgqdl4gll4wvgpr190kinzhv88idnn9pxm96";
12+ } rec {
8− ghc-check = self.callHackageDirect {
13+ ghc-check = callHackageDirect {
9− pkg = "ghc-check";
14+ pkg = "ghc-check";
10− ver = "0.1.0.3";
15+ ver = "0.3.0.1";
11− sha256 = "038llbvryk5y27jbdpbshp0zw5lw1j6m7qk7vx1n96ykqdzkh649";
16+ sha256 = "1dj909m09m24315x51vxvcl28936ahsw4mavbc53danif3wy09ns";
12− } {};
17+ } { };
13− lsp-test = dontCheck (self.callHackage "lsp-test" "0.6.1.0" {});
18+ lsp-test = dontCheck (callHackage "lsp-test" "0.6.1.0" { });
14− haddock-library = dontCheck (self.callHackage "haddock-library" "1.8.0" {});
19+ haddock-library = dontCheck (callHackage "haddock-library" "1.8.0" { });
15− haskell-lsp = dontCheck (self.callHackage "haskell-lsp" "0.19.0.0" {});
20+ haskell-lsp = dontCheck (callHackageDirect {
21+ pkg = "haskell-lsp";
22+ ver = "0.22.0.0";
23+ sha256 = "1q3w46qcvzraxgmw75s7bl0qvb2fvff242r5vfx95sqska566b4m";
24+ } { inherit haskell-lsp-types; });
16− haskell-lsp-types = dontCheck (self.callHackage "haskell-lsp-types" "0.19.0.0" {});
25+ haskell-lsp-types = dontCheck (callHackageDirect {
17− regex-posix = dontCheck (self.callHackage "regex-posix" "0.96.0.0" {});
26+ pkg = "haskell-lsp-types";
27+ ver = "0.22.0.0";
28+ sha256 = "1apjclphi2v6ggrdnbc0azxbb1gkfj3x1vkwpc8qd6lsrbyaf0n8";
29+ } { });
18− test-framework = dontCheck (self.callHackage "test-framework" "0.8.2.0" {});
30+ regex-tdfa = dontCheck (callHackage "regex-tdfa" "1.3.1.0" {
19− regex-base = dontCheck (self.callHackage "regex-base" "0.94.0.0" {});
31+ regex-base = dontCheck (callHackage "regex-base" "0.94.0.0" { });
20− regex-tdfa = dontCheck (self.callHackage "regex-tdfa" "1.3.1.0" {});
32+ });
21− shake = dontCheck (self.callHackage "shake" "0.18.4" {});
33+ shake = dontCheck (callHackage "shake" "0.18.4" { });
22− hie-bios = dontCheck (self.callHackageDirect {
34+ hie-bios = dontCheck (callHackageDirect {
23− pkg = "hie-bios";
35+ pkg = "hie-bios";
24− ver = "0.4.0";
36+ ver = "0.5.0";
25− sha256 = "19lpg9ymd9656cy17vna8wr1hvzfal94gpm2d3xpnw1d5qr37z7x";
37+ sha256 = "116nmpva5jmlgc2dgy8cm5wv6cinhzmga1l0432p305074w720r2";
26− } {});
38+ } { });
27− };
28− }).callCabal2nix "ghcide" (pkgs.fetchFromGitHub {
29− owner = "digital-asset";
30− repo = "ghcide";
31− rev = "v0.1.0";
32− sha256 = "1kf71iix46hvyxviimrcv7kvsj67hcnnqlpdsmazmlmybf7wbqbb";
33− }) {}));
39+ }));
34}
40}
haskell-overlays/misc-deps.nix+8−2
@@ -9,8 +9,14 @@ let
9in
9in
10
10
11{
11{
12− hnix = haskellLib.dontCheck (haskellLib.doJailbreak (self.callCabal2nix "hnix" (hackGet ../dep/hnix) {}));
12+ regex-base = self.callHackage "regex-base" "0.94.0.0" {};
13+ regex-posix = self.callHackage "regex-posix" "0.96.0.0" {};
14+ regex-tdfa = self.callHackage "regex-tdfa" "1.3.1.0" {};
15+ test-framework = haskellLib.dontCheck (self.callHackage "test-framework" "0.8.2.0" {});
16+ hnix = haskellLib.dontCheck (self.callHackage "hnix" "0.8.0" {});
13− hnix-store-core = self.callHackage "hnix-store-core" "0.1.0.0" {};
17+ hnix-store-core = self.callHackage "hnix-store-core" "0.2.0.0" {};
18+
19+ aeson-gadt-th = self.callHackage "aeson-gadt-th" "0.2.4" {};
14
20
15 ghcid = self.callCabal2nix "ghcid" (hackGet ../dep/ghcid) {};
21 ghcid = self.callCabal2nix "ghcid" (hackGet ../dep/ghcid) {};
16 # Exports more internals
22 # Exports more internals
haskell-overlays/obelisk.nix+5
@@ -19,7 +19,12 @@ in
19 obelisk-command = haskellLib.overrideCabal (self.callCabal2nix "obelisk-command" (obeliskCleanSource ../lib/command) {}) {
19 obelisk-command = haskellLib.overrideCabal (self.callCabal2nix "obelisk-command" (obeliskCleanSource ../lib/command) {}) {
20 librarySystemDepends = [
20 librarySystemDepends = [
21 pkgs.jre
21 pkgs.jre
22+ pkgs.git
22 pkgs.nix
23 pkgs.nix
24+ pkgs.nix-prefetch-git
25+ pkgs.openssh
26+ pkgs.rsync
27+ pkgs.which
23 (haskellLib.justStaticExecutables self.ghcid)
28 (haskellLib.justStaticExecutables self.ghcid)
24 ];
29 ];
25 };
30 };
lib/asset/README.md+16−19
@@ -1,29 +1,26 @@
1−## obelisk-asset
1+# obelisk-asset
2
2
3−The 'assets.nix' file contains nix expressions that are a mutually
3+[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)](http://www.haskell.org)
4−recursive set of attributes used to create static asset directories
4+[![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)](https://github.com/obsidiansystems/obelisk/blob/master/LICENSE)
5−with hashable file encodings. This file should be incorporated within
6−your project's 'default.nix' file. (See ./example/default.nix , line 2)
7−```
8−{assets ? import ./../assets.nix { inherit nixpkgs; }
9−}:
10−```
11
5
12−The 'mkAssets' and 'mkAssetsWith' functions within 'assets.nix' only
6+**Efficiently served, aggressively cached static web resources.**
13−need to be passed an encoding('zopfliEncodings', 'gzipEncodings',
14−'noEncodings') and a static directory of your choice as arguments.
15
7
16−In this example, 'mkAssets' is used on a directory that has a .png
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)
17−file inside of it. (See ./example/default.nix, line 11)
9+
10+```nix
11+{ assets ? import ./../assets.nix { inherit nixpkgs; } }:
18```
12```
13+
14+The `mkAssets` and `mkAssetsWith` functions within `assets.nix` only need to be passed an `encoding("zopfliEncodings", "gzipEncodings", "noEncodings")` and a static directory of your choice as arguments.
15+
16+In this example, `mkAssets` is used on a directory that has a `.png` file inside of it. (See `example/default.nix`, line 11)
17+
18+```nix
19myAssets = assets.mkAssets ./static;
19myAssets = assets.mkAssets ./static;
20```
20```
21
21
22−Once you have successfully incorporated 'assets.nix' into your
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−project's nix file(s), use nix-build to generate a symlink of
23+
24−your 'mkAssets' expression. The following command from
25−example/run-example (line 3) will generate an immutable symlink
26−that holds hashed static assets.
27```bash
24```bash
28nix-build -o static.assets -A myAssets
25nix-build -o static.assets -A myAssets
29```
26```
lib/asset/assets.nix+28−5
@@ -20,7 +20,7 @@ zopfliEncodings = file:
20 nixpkgs.stdenv.mkDerivation {
20 nixpkgs.stdenv.mkDerivation {
21 name = "encodings";
21 name = "encodings";
22
22
23− input = file;
23+ input = mkPath file;
24
24
25 builder = builtins.toFile "builder.sh" ''
25 builder = builtins.toFile "builder.sh" ''
26 source "$stdenv/setup"
26 source "$stdenv/setup"
@@ -46,7 +46,7 @@ gzipEncodings = file:
46 nixpkgs.stdenv.mkDerivation {
46 nixpkgs.stdenv.mkDerivation {
47 name = "encodings";
47 name = "encodings";
48
48
49− input = file;
49+ input = mkPath file;
50
50
51 builder = builtins.toFile "builder.sh" ''
51 builder = builtins.toFile "builder.sh" ''
52 source "$stdenv/setup"
52 source "$stdenv/setup"
@@ -70,7 +70,7 @@ noEncodings = file:
70 nixpkgs.stdenv.mkDerivation {
70 nixpkgs.stdenv.mkDerivation {
71 name = "encodings";
71 name = "encodings";
72
72
73− input = file;
73+ input = mkPath file;
74
74
75 builder = builtins.toFile "builder.sh" ''
75 builder = builtins.toFile "builder.sh" ''
76 source "$stdenv/setup"
76 source "$stdenv/setup"
@@ -203,7 +203,7 @@ hashFile = path:
203 nixpkgs.nix
203 nixpkgs.nix
204 ];
204 ];
205 preferLocalBuild = true;
205 preferLocalBuild = true;
206− inherit path;
206+ path = mkPath path;
207 } ''
207 } ''
208 nix-hash --flat --base32 --type sha256 "$path" | tr -d '\n' >"$out"
208 nix-hash --flat --base32 --type sha256 "$path" | tr -d '\n' >"$out"
209 '');
209 '');
@@ -224,7 +224,30 @@ symlink = path: {
224 inherit path;
224 inherit path;
225};
225};
226
226
227+# Tests if a given character (string of length 1) is valid for a derivation path name.
228+# Passing a string of length other than 1 is undefined.
229+# :: Char -> Bool
230+isValidDrvNameChar = c: "a" <= c && c <= "z" || "A" <= c && c <= "Z" || "0" <= c && c <= "9" || c == "+" || c == "-" || c == "_" || c == "?" || c == "=" || c == ".";
231+
232+# Convert a string into a string that could be used in a derivation name.
233+# replacement lets you choose how to replace invalid characters. It may be any length.
234+# If it contains invalid characters then the result will also be invalid.
235+# :: { str :: String, replacement :: String } -> String
236+mkValidDrvName = { str, replacement ? "?" }:
237+ let
238+ newName = stringAsChars (c: if isValidDrvNameChar c then c else replacement) str;
239+ in if builtins.substring 0 1 newName == "." then "_" + newName else newName;
240+
241+# Like builtins.path but always ensures the name is valid.
242+mkPath = path:
243+ if builtins.typeOf path == "path" # Don't mess with non-paths
244+ then builtins.path {
245+ inherit path;
246+ name = mkValidDrvName { str = builtins.baseNameOf path; };
247+ }
248+ else path;
249+
227−# Given a encoding generation function and a file entry resulting from readDirRecursive in the form { name :: String, value: { path :: String } },
250+# Given an encoding generation function and a file entry resulting from readDirRecursive in the form { name :: String, value: { path :: String } },
228# build a DirEntry for dirToPath with the various encodings of the asset for dirToPath to build into a final directory tree.
251# build a DirEntry for dirToPath with the various encodings of the asset for dirToPath to build into a final directory tree.
229mkAsset = encodings: {name, value}:
252mkAsset = encodings: {name, value}:
230 let nameWithHash = "${hashFile value.path}-${name}";
253 let nameWithHash = "${hashFile value.path}-${name}";
lib/asset/manifest/obelisk-asset-manifest.cabal+4−2
@@ -24,7 +24,7 @@ library
24 , template-haskell
24 , template-haskell
25 , text
25 , text
26 , transformers
26 , transformers
27− , unix
27+ , unix-compat
28 , vector
28 , vector
29 exposed-modules:
29 exposed-modules:
30 Obelisk.Asset.Gather
30 Obelisk.Asset.Gather
@@ -33,7 +33,9 @@ library
33 Obelisk.Asset.TH
33 Obelisk.Asset.TH
34
34
35 other-extensions: TemplateHaskell
35 other-extensions: TemplateHaskell
36+ ghc-options:
37+ -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O2
36− ghc-options: -Wall -Werror -fno-warn-unused-do-bind -fwarn-tabs -funbox-strict-fields -O2 -fprof-auto-calls
38+ -fno-warn-unused-do-bind -funbox-strict-fields -fprof-auto-calls
37
39
38executable obelisk-asset-manifest-generate
40executable obelisk-asset-manifest-generate
39 hs-source-dirs: src-bin
41 hs-source-dirs: src-bin
lib/asset/manifest/src/Obelisk/Asset/Symlink.hs+1−1
@@ -7,7 +7,7 @@ import Data.Map (Map)
7import qualified Data.Map as Map
7import qualified Data.Map as Map
8import System.Directory
8import System.Directory
9import System.FilePath.Posix
9import System.FilePath.Posix
10−import System.Posix.Files
10+import System.PosixCompat.Files
11
11
12-- | Copy the given hashed files from one location to hashed paths in another
12-- | Copy the given hashed files from one location to hashed paths in another
13-- location, and symlink the unhashed paths to the hashed ones
13-- location, and symlink the unhashed paths to the hashed ones
lib/asset/serve-snap/obelisk-asset-serve-snap.cabal+4−2
@@ -23,10 +23,12 @@ library
23 , obelisk-snap-extras
23 , obelisk-snap-extras
24 , text
24 , text
25 , transformers
25 , transformers
26− , unix
26+ , unix-compat
27 exposed-modules:
27 exposed-modules:
28 Obelisk.Asset.Accept
28 Obelisk.Asset.Accept
29 Obelisk.Asset.Serve.Snap
29 Obelisk.Asset.Serve.Snap
30
30
31 other-extensions: TemplateHaskell
31 other-extensions: TemplateHaskell
32+ ghc-options:
33+ -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O2
32− ghc-options: -Wall -Werror -fno-warn-unused-do-bind -fwarn-tabs -funbox-strict-fields -O2 -fprof-auto-calls
34+ -fno-warn-unused-do-bind -funbox-strict-fields -fprof-auto-calls
lib/asset/serve-snap/src/Obelisk/Asset/Serve/Snap.hs+1−1
@@ -31,7 +31,7 @@ import Data.Text.Encoding (decodeUtf8, encodeUtf8)
31import System.Directory (getDirectoryContents)
31import System.Directory (getDirectoryContents)
32import System.FilePath ((</>), splitFileName, takeDirectory)
32import System.FilePath ((</>), splitFileName, takeDirectory)
33import System.IO.Error (isDoesNotExistError)
33import System.IO.Error (isDoesNotExistError)
34−import System.Posix (getFileStatus, fileSize)
34+import System.PosixCompat.Files (getFileStatus, fileSize)
35
35
36-- | Serve static assets from an asset directory generated via @assets.nix@ or, failing that, from a regular directory.
36-- | Serve static assets from an asset directory generated via @assets.nix@ or, failing that, from a regular directory.
37--
37--
lib/backend/obelisk-backend.cabal+2−2
@@ -21,10 +21,10 @@ library
21 obelisk-frontend,
21 obelisk-frontend,
22 obelisk-route,
22 obelisk-route,
23 obelisk-snap-extras,
23 obelisk-snap-extras,
24− reflex-dom,
24+ reflex-dom-core,
25 snap,
25 snap,
26 snap-server,
26 snap-server,
27 text,
27 text,
28 universe
28 universe
29 exposed-modules: Obelisk.Backend
29 exposed-modules: Obelisk.Backend
30− ghc-options: -Wall
30+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/backend/src/Obelisk/Backend.hs+1−1
@@ -58,7 +58,7 @@ import qualified Obelisk.ExecutableConfig.Lookup as Lookup
58import Obelisk.Frontend
58import Obelisk.Frontend
59import Obelisk.Route
59import Obelisk.Route
60import Obelisk.Snap.Extras (doNotCache, serveFileIfExistsAs)
60import Obelisk.Snap.Extras (doNotCache, serveFileIfExistsAs)
61−import Reflex.Dom
61+import Reflex.Dom.Core
62import Snap (MonadSnap, Snap, commandLineConfig, defaultConfig, getsRequest, httpServe, modifyResponse
62import Snap (MonadSnap, Snap, commandLineConfig, defaultConfig, getsRequest, httpServe, modifyResponse
63 , rqPathInfo, rqQueryString, setContentType, writeBS, writeText
63 , rqPathInfo, rqQueryString, setContentType, writeBS, writeText
64 , rqCookies, Cookie(..) , setHeader)
64 , rqCookies, Cookie(..) , setHeader)
lib/cliapp/obelisk-cliapp.cabal+1−1
@@ -34,4 +34,4 @@ library
34 Obelisk.CliApp.TerminalString
34 Obelisk.CliApp.TerminalString
35 Obelisk.CliApp.Theme
35 Obelisk.CliApp.Theme
36 Obelisk.CliApp.Types
36 Obelisk.CliApp.Types
37− ghc-options: -Wall -fobject-code
37+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/cliapp/src/Obelisk/CliApp.hs+3
@@ -39,7 +39,9 @@ module Obelisk.CliApp
39 , callCommand
39 , callCommand
40 , callProcess
40 , callProcess
41 , callProcessAndLogOutput
41 , callProcessAndLogOutput
42+ , createProcess
42 , createProcess_
43 , createProcess_
44+ , exitCodeToException
43 , overCreateProcess
45 , overCreateProcess
44 , proc
46 , proc
45 , readCreateProcessWithExitCode
47 , readCreateProcessWithExitCode
@@ -47,6 +49,7 @@ module Obelisk.CliApp
47 , readProcessAndLogStderr
49 , readProcessAndLogStderr
48 , readProcessJSONAndLogStderr
50 , readProcessJSONAndLogStderr
49 , reconstructCommand
51 , reconstructCommand
52+ , runProcess_
50 , setCwd
53 , setCwd
51 , setDelegateCtlc
54 , setDelegateCtlc
52 , setEnvOverride
55 , setEnvOverride
lib/cliapp/src/Obelisk/CliApp/Logging.hs+2−2
@@ -160,7 +160,7 @@ failWith :: (CliThrow e m, AsUnstructuredError e) => Text -> m a
160failWith = throwError . review asUnstructuredError
160failWith = throwError . review asUnstructuredError
161
161
162errorToWarning
162errorToWarning
163− :: (HasCliConfig e m, CliThrow e m, CliLog m)
163+ :: (HasCliConfig e m, CliLog m)
164 => e -> m ()
164 => e -> m ()
165errorToWarning e = do
165errorToWarning e = do
166 c <- getCliConfig
166 c <- getCliConfig
@@ -177,7 +177,7 @@ withExitFailMessage msg f = f `catch` \(e :: ExitCode) -> do
177 throwM e
177 throwM e
178
178
179-- | Write log to stdout, with colors (unless `noColor`)
179-- | Write log to stdout, with colors (unless `noColor`)
180−writeLog :: (MonadIO m, MonadMask m) => Bool -> Bool -> WithSeverity Text -> m ()
180+writeLog :: (MonadIO m) => Bool -> Bool -> WithSeverity Text -> m ()
181writeLog withNewLine noColor (WithSeverity severity s) = if T.null s then pure () else write
181writeLog withNewLine noColor (WithSeverity severity s) = if T.null s then pure () else write
182 where
182 where
183 write
183 write
lib/cliapp/src/Obelisk/CliApp/Process.hs+44−27
@@ -1,7 +1,6 @@
1{-# LANGUAGE FlexibleContexts #-}
1{-# LANGUAGE FlexibleContexts #-}
2{-# LANGUAGE LambdaCase #-}
2{-# LANGUAGE LambdaCase #-}
3{-# LANGUAGE MultiParamTypeClasses #-}
3{-# LANGUAGE MultiParamTypeClasses #-}
4−{-# LANGUAGE MultiWayIf #-}
5{-# LANGUAGE OverloadedStrings #-}
4{-# LANGUAGE OverloadedStrings #-}
6{-# LANGUAGE ScopedTypeVariables #-}
5{-# LANGUAGE ScopedTypeVariables #-}
7{-# LANGUAGE TupleSections #-}
6{-# LANGUAGE TupleSections #-}
@@ -17,6 +16,7 @@ module Obelisk.CliApp.Process
17 , callProcessAndLogOutput
16 , callProcessAndLogOutput
18 , createProcess
17 , createProcess
19 , createProcess_
18 , createProcess_
19+ , exitCodeToException
20 , overCreateProcess
20 , overCreateProcess
21 , proc
21 , proc
22 , readCreateProcessWithExitCode
22 , readCreateProcessWithExitCode
@@ -24,6 +24,7 @@ module Obelisk.CliApp.Process
24 , readProcessAndLogStderr
24 , readProcessAndLogStderr
25 , readProcessJSONAndLogStderr
25 , readProcessJSONAndLogStderr
26 , reconstructCommand
26 , reconstructCommand
27+ , runProcess_
27 , setCwd
28 , setCwd
28 , setDelegateCtlc
29 , setDelegateCtlc
29 , setEnvOverride
30 , setEnvOverride
@@ -32,6 +33,7 @@ module Obelisk.CliApp.Process
32 ) where
33 ) where
33
34
34import Control.Monad ((<=<), join, void)
35import Control.Monad ((<=<), join, void)
36+import Control.Monad.Catch (MonadMask, bracketOnError)
35import Control.Monad.Except (throwError)
37import Control.Monad.Except (throwError)
36import Control.Monad.Fail
38import Control.Monad.Fail
37import Control.Monad.IO.Class (MonadIO, liftIO)
39import Control.Monad.IO.Class (MonadIO, liftIO)
@@ -99,7 +101,7 @@ instance AsProcessFailure ProcessFailure where
99 asProcessFailure = id
101 asProcessFailure = id
100
102
101readProcessAndLogStderr
103readProcessAndLogStderr
102− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
104+ :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)
103 => Severity -> ProcessSpec -> m Text
105 => Severity -> ProcessSpec -> m Text
104readProcessAndLogStderr sev process = do
106readProcessAndLogStderr sev process = do
105 (out, _err) <- withProcess process $ \_out err -> do
107 (out, _err) <- withProcess process $ \_out err -> do
@@ -107,7 +109,7 @@ readProcessAndLogStderr sev process = do
107 liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out
109 liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out
108
110
109readProcessJSONAndLogStderr
111readProcessJSONAndLogStderr
110− :: (Aeson.FromJSON a, MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
112+ :: (Aeson.FromJSON a, MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)
111 => Severity -> ProcessSpec -> m a
113 => Severity -> ProcessSpec -> m a
112readProcessJSONAndLogStderr sev process = do
114readProcessJSONAndLogStderr sev process = do
113 (out, _err) <- withProcess process $ \_out err -> do
115 (out, _err) <- withProcess process $ \_out err -> do
@@ -120,7 +122,7 @@ readProcessJSONAndLogStderr sev process = do
120 throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) 0
122 throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) 0
121
123
122readCreateProcessWithExitCode
124readCreateProcessWithExitCode
123− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e)
125+ :: (MonadIO m, CliLog m)
124 => ProcessSpec -> m (ExitCode, String, String)
126 => ProcessSpec -> m (ExitCode, String, String)
125readCreateProcessWithExitCode procSpec = do
127readCreateProcessWithExitCode procSpec = do
126 process <- mkCreateProcess procSpec
128 process <- mkCreateProcess procSpec
@@ -130,10 +132,10 @@ readCreateProcessWithExitCode procSpec = do
130-- | Like `System.Process.readProcess` but logs the combined output (stdout and stderr)
132-- | Like `System.Process.readProcess` but logs the combined output (stdout and stderr)
131-- with the corresponding severity.
133-- with the corresponding severity.
132--
134--
133−-- Usually this function is called as `callProcessAndLogOutput (Debug, Error)`. However
135+-- Usually this function is called as `readProcessAndLogOutput (Debug, Error)`. However
134-- some processes are known to spit out diagnostic or informative messages in stderr, in
136-- some processes are known to spit out diagnostic or informative messages in stderr, in
135-- which case it is advisable to call it with a non-Error severity for stderr, like
137-- which case it is advisable to call it with a non-Error severity for stderr, like
136−-- `callProcessAndLogOutput (Debug, Debug)`.
138+-- `readProcessAndLogOutput (Debug, Debug)`.
137readProcessAndLogOutput
139readProcessAndLogOutput
138 :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
140 :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
139 => (Severity, Severity) -> ProcessSpec -> m Text
141 => (Severity, Severity) -> ProcessSpec -> m Text
@@ -146,9 +148,7 @@ readProcessAndLogOutput (sev_out, sev_err) process = do
146 outText <- liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out
148 outText <- liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out
147 putLogRaw sev_out outText
149 putLogRaw sev_out outText
148
150
149− waitForProcess p >>= \case
151+ outText <$ (exitCodeToException process =<< waitForProcess p)
150− ExitSuccess -> pure outText
151− ExitFailure code -> throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) code
152
152
153-- | Like 'System.Process.callProcess' but logs the combined output (stdout and stderr)
153-- | Like 'System.Process.callProcess' but logs the combined output (stdout and stderr)
154-- with the corresponding severity.
154-- with the corresponding severity.
@@ -158,7 +158,7 @@ readProcessAndLogOutput (sev_out, sev_err) process = do
158-- which case it is advisable to call it with a non-Error severity for stderr, like
158-- which case it is advisable to call it with a non-Error severity for stderr, like
159-- `callProcessAndLogOutput (Debug, Debug)`.
159-- `callProcessAndLogOutput (Debug, Debug)`.
160callProcessAndLogOutput
160callProcessAndLogOutput
161− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
161+ :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)
162 => (Severity, Severity) -> ProcessSpec -> m ()
162 => (Severity, Severity) -> ProcessSpec -> m ()
163callProcessAndLogOutput (sev_out, sev_err) process =
163callProcessAndLogOutput (sev_out, sev_err) process =
164 void $ withProcess process $ \out err -> do
164 void $ withProcess process $ \out err -> do
@@ -188,12 +188,11 @@ createProcess_ name procSpec = do
188 liftIO $ Process.createProcess_ name p
188 liftIO $ Process.createProcess_ name p
189
189
190mkCreateProcess :: MonadIO m => ProcessSpec -> m Process.CreateProcess
190mkCreateProcess :: MonadIO m => ProcessSpec -> m Process.CreateProcess
191−mkCreateProcess (ProcessSpec p override') = do
191+mkCreateProcess (ProcessSpec p override') = case override' of
192− case override' of
193− Nothing -> pure p
192+ Nothing -> pure p
194− Just override -> do
193+ Just override -> do
195− procEnv <- Map.fromList <$> maybe (liftIO getEnvironment) pure (Process.env p)
194+ procEnv <- Map.fromList <$> maybe (liftIO getEnvironment) pure (Process.env p)
196− pure $ p { Process.env = Just $ Map.toAscList (override procEnv) }
195+ pure $ p { Process.env = Just $ Map.toAscList (override procEnv) }
197
196
198-- | Like `System.Process.callProcess` but also logs (debug) the process being run
197-- | Like `System.Process.callProcess` but also logs (debug) the process being run
199callProcess
198callProcess
@@ -212,18 +211,30 @@ callCommand cmd = do
212 liftIO $ Process.callCommand cmd
211 liftIO $ Process.callCommand cmd
213
212
214withProcess
213withProcess
215− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m)
214+ :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)
216 => ProcessSpec -> (Handle -> Handle -> m ()) -> m (Handle, Handle)
215 => ProcessSpec -> (Handle -> Handle -> m ()) -> m (Handle, Handle)
217−withProcess process f = do -- TODO: Use bracket.
216+withProcess process f =
218− -- FIXME: Using `withCreateProcess` here leads to something operating illegally on closed handles.
217+ bracketOnError
219− (_, Just out, Just err, p) <- createProcess $ overCreateProcess
218+ (createProcess $ overCreateProcess
220− (\x -> x { std_out = CreatePipe , std_err = CreatePipe }) process
219+ (\x -> x { std_out = CreatePipe , std_err = CreatePipe }) process
221−
220+ )
222− f out err -- Pass the handles to the passed function
221+ (liftIO . Process.cleanupProcess)
223−
222+ (\case
224− waitForProcess p >>= \case
223+ (_, Just out, Just err, p) -> do
225− ExitSuccess -> return (out, err)
224+ f out err
226− ExitFailure code -> throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) code
225+ (out, err) <$ (exitCodeToException process =<< waitForProcess p)
226+ _ -> error "withProcess: createProcess did not provide handles for CreatePipe as expected"
227+ )
228+
229+-- | Runs a process to completion failing if it does not exit cleanly.
230+runProcess_
231+ :: (MonadIO m, CliLog m, CliThrow e m, MonadMask m, AsProcessFailure e)
232+ => ProcessSpec -> m ()
233+runProcess_ process =
234+ bracketOnError
235+ (createProcess process)
236+ (liftIO . Process.cleanupProcess)
237+ (\(_, _, _, ph) -> exitCodeToException process =<< waitForProcess ph)
227
238
228-- Create an input stream from the file handle, associating each item with the given severity.
239-- Create an input stream from the file handle, associating each item with the given severity.
229streamHandle :: Severity -> Handle -> IO (InputStream (Severity, BSC.ByteString))
240streamHandle :: Severity -> Handle -> IO (InputStream (Severity, BSC.ByteString))
@@ -242,6 +253,12 @@ streamToLog stream = fix $ \loop -> do
242waitForProcess :: MonadIO m => ProcessHandle -> m ExitCode
253waitForProcess :: MonadIO m => ProcessHandle -> m ExitCode
243waitForProcess = liftIO . Process.waitForProcess
254waitForProcess = liftIO . Process.waitForProcess
244
255
256+-- | Converts an 'ExitCode' to an exception when it's non-zero.
257+exitCodeToException :: (CliThrow e m, AsProcessFailure e) => ProcessSpec -> ExitCode -> m ()
258+exitCodeToException spec = \case
259+ ExitSuccess -> pure ()
260+ ExitFailure code -> throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess spec) code
261+
245-- | Pretty print a 'CmdSpec'
262-- | Pretty print a 'CmdSpec'
246reconstructCommand :: Process.CmdSpec -> Text
263reconstructCommand :: Process.CmdSpec -> Text
247reconstructCommand p = case p of
264reconstructCommand p = case p of
lib/command/obelisk-command.cabal+3−3
@@ -1,5 +1,5 @@
1name: obelisk-command
1name: obelisk-command
2−version: 0.8.0.0
2+version: 0.9.0.1
3cabal-version: >= 1.8
3cabal-version: >= 1.8
4build-type: Simple
4build-type: Simple
5
5
@@ -45,7 +45,7 @@ library
45 , text
45 , text
46 , time
46 , time
47 , transformers
47 , transformers
48− , unix
48+ , unix-compat
49 , unordered-containers
49 , unordered-containers
50 , utf8-string
50 , utf8-string
51 , which
51 , which
@@ -66,4 +66,4 @@ library
66executable ob
66executable ob
67 main-is: src-bin/ob.hs
67 main-is: src-bin/ob.hs
68 build-depends: base, obelisk-command
68 build-depends: base, obelisk-command
69− ghc-options: -Wall -O2 -threaded
69+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O -threaded
lib/command/src/Obelisk/Command.hs+9−5
@@ -22,7 +22,7 @@ import System.Environment
22import System.FilePath
22import System.FilePath
23import qualified System.Info
23import qualified System.Info
24import System.IO (hIsTerminalDevice, stdout)
24import System.IO (hIsTerminalDevice, stdout)
25−import System.Posix.Process (executeFile)
25+import System.Process (rawSystem)
26
26
27import Obelisk.App
27import Obelisk.App
28import Obelisk.CliApp
28import Obelisk.CliApp
@@ -114,7 +114,7 @@ obCommand cfg = hsubparser
114 , command "thunk" $ info (ObCommand_Thunk <$> thunkOption) $ progDesc "Manipulate thunk directories"
114 , command "thunk" $ info (ObCommand_Thunk <$> thunkOption) $ progDesc "Manipulate thunk directories"
115 , command "repl" $ info (ObCommand_Repl <$> interpretOpts) $ progDesc "Open an interactive interpreter"
115 , command "repl" $ info (ObCommand_Repl <$> interpretOpts) $ progDesc "Open an interactive interpreter"
116 , command "watch" $ info (ObCommand_Watch <$> interpretOpts) $ progDesc "Watch current project for errors and warnings"
116 , command "watch" $ info (ObCommand_Watch <$> interpretOpts) $ progDesc "Watch current project for errors and warnings"
117− , command "shell" $ info (ObCommand_Shell <$> shellOpts) $ progDesc "Enter a shell with project dependencies"
117+ , command "shell" $ info (ObCommand_Shell <$> shellOpts) $ progDesc "Enter a shell with project dependencies or run a command in such a shell. E.g. ob shell -- ghc-pkg list"
118 , command "doc" $ info (ObCommand_Doc <$> shellFlags <*> packageNames) $
118 , command "doc" $ info (ObCommand_Doc <$> shellFlags <*> packageNames) $
119 progDesc "List paths to haddock documentation for specified packages"
119 progDesc "List paths to haddock documentation for specified packages"
120 <> footerDoc (Just $
120 <> footerDoc (Just $
@@ -285,7 +285,10 @@ shellOpts :: Parser ShellOpts
285shellOpts = ShellOpts
285shellOpts = ShellOpts
286 <$> shellFlags
286 <$> shellFlags
287 <*> interpretOpts
287 <*> interpretOpts
288+ -- This funny construction is used to support optparse-applicative's @--@ parsing.
289+ -- All arguments after @--@ are left unparsed and instead provided to the last positional parser
290+ -- which must therefore be 'many' in order to consume the rest of the input.
288− <*> optional (strArgument (metavar "COMMAND"))
291+ <*> ((\xs -> if null xs then Nothing else Just $ unwords xs) <$> many (strArgument (metavar "COMMAND")))
289
292
290portOpt :: Int -> Parser Int
293portOpt :: Int -> Parser Int
291portOpt dfault = option auto (long "port" <> short 'p' <> help "Port number for server" <> showDefault <> value dfault <> metavar "INT")
294portOpt dfault = option auto (long "port" <> short 'p' <> help "Port number for server" <> showDefault <> value dfault <> metavar "INT")
@@ -363,7 +366,8 @@ main' argsCfg = do
363 Just impl -> do
366 Just impl -> do
364 -- Invoke the real implementation, using --no-handoff to prevent infinite recursion
367 -- Invoke the real implementation, using --no-handoff to prevent infinite recursion
365 putLog Debug $ "Handing off to " <> T.pack impl
368 putLog Debug $ "Handing off to " <> T.pack impl
366− liftIO $ executeFile impl False ("--no-handoff" : myArgs) Nothing
369+ _ <- liftIO $ rawSystem impl ("--no-handoff" : myArgs)
370+ return ()
367 case myArgs of
371 case myArgs of
368 "--no-handoff" : as -> go as -- If we've been told not to hand off, don't hand off
372 "--no-handoff" : as -> go as -- If we've been told not to hand off, don't hand off
369 origPath:inPath:outPath:preprocessorName:packagePaths
373 origPath:inPath:outPath:preprocessorName:packagePaths
@@ -398,7 +402,7 @@ ob = \case
398 ObCommand_Repl interpretPathsList -> withInterpretPaths interpretPathsList runRepl
402 ObCommand_Repl interpretPathsList -> withInterpretPaths interpretPathsList runRepl
399 ObCommand_Watch interpretPathsList -> withInterpretPaths interpretPathsList runWatch
403 ObCommand_Watch interpretPathsList -> withInterpretPaths interpretPathsList runWatch
400 ObCommand_Shell (ShellOpts shellAttr interpretPathsList cmd) -> withInterpretPaths interpretPathsList $ \root interpretPaths ->
404 ObCommand_Shell (ShellOpts shellAttr interpretPathsList cmd) -> withInterpretPaths interpretPathsList $ \root interpretPaths ->
401− nixShellForInterpretPaths False shellAttr root interpretPaths (bashEscape <$> cmd)
405+ nixShellForInterpretPaths False shellAttr root interpretPaths cmd -- N.B. We do NOT bash escape here; we want to run the command as-is
402 ObCommand_Doc shellAttr pkgs -> withInterpretPaths [] $ \root interpretPaths ->
406 ObCommand_Doc shellAttr pkgs -> withInterpretPaths [] $ \root interpretPaths ->
403 nixShellForInterpretPaths True shellAttr root interpretPaths $ Just $ haddockCommand pkgs
407 nixShellForInterpretPaths True shellAttr root interpretPaths $ Just $ haddockCommand pkgs
404 ObCommand_Hoogle shell' port -> withProjectRoot "." $ \root -> do
408 ObCommand_Hoogle shell' port -> withProjectRoot "." $ \root -> do
lib/command/src/Obelisk/Command/Deploy.hs+16−16
@@ -25,7 +25,7 @@ import GHC.Generics
25import System.Directory
25import System.Directory
26import System.FilePath
26import System.FilePath
27import System.IO
27import System.IO
28−import System.Posix.Files
28+import System.PosixCompat.Files
29import Text.URI (URI)
29import Text.URI (URI)
30import qualified Text.URI as URI
30import qualified Text.URI as URI
31import Text.URI.Lens
31import Text.URI.Lens
@@ -85,13 +85,12 @@ deployInit' thunkPtr (DeployInitOpts deployDir sshKeyPath hostnames route adminE
85 --accidentally create a production deployment that uses development
85 --accidentally create a production deployment that uses development
86 --credentials to connect to some resources. This could result in, e.g.,
86 --credentials to connect to some resources. This could result in, e.g.,
87 --production data backed up to a dev environment.
87 --production data backed up to a dev environment.
88− withSpinner "Creating project configuration directories" $ do
88+ withSpinner "Creating project configuration directories" $ liftIO $ do
89− callProcessAndLogOutput (Notice, Error) $
89+ mapM_ (createDirectoryIfMissing True)
90− proc "mkdir" [ "-p"
91− , deployDir </> "config" </> "backend"
90+ [ deployDir </> "config" </> "backend"
92− , deployDir </> "config" </> "common"
91+ , deployDir </> "config" </> "common"
93− , deployDir </> "config" </> "frontend"
92+ , deployDir </> "config" </> "frontend"
94− ]
93+ ]
95
94
96 let srcDir = deployDir </> "src"
95 let srcDir = deployDir </> "src"
97 withSpinner ("Creating source thunk (" <> T.pack (makeRelative deployDir srcDir) <> ")") $ do
96 withSpinner ("Creating source thunk (" <> T.pack (makeRelative deployDir srcDir) <> ")") $ do
@@ -162,8 +161,8 @@ deployPush deployPath getNixBuilders = do
162 "nix-copy-closure" ["-v", "--to", "--use-substitutes", "root@" <> host, "--gzip", outputPath]
161 "nix-copy-closure" ["-v", "--to", "--use-substitutes", "root@" <> host, "--gzip", outputPath]
163 withSpinner "Uploading config" $ ifor_ buildOutputByHost $ \host _ -> do
162 withSpinner "Uploading config" $ ifor_ buildOutputByHost $ \host _ -> do
164 callProcessAndLogOutput (Notice, Warning) $
163 callProcessAndLogOutput (Notice, Warning) $
165− proc "rsync"
164+ proc rsyncPath
166− [ "-e ssh " <> unwords sshOpts
165+ [ "-e " <> sshPath <> " " <> unwords sshOpts
167 , "-qarvz"
166 , "-qarvz"
168 , deployPath </> "config"
167 , deployPath </> "config"
169 , "root@" <> host <> ":/var/lib/backend"
168 , "root@" <> host <> ":/var/lib/backend"
@@ -171,9 +170,10 @@ deployPush deployPath getNixBuilders = do
171 --TODO: Create GC root so we're sure our closure won't go away during this time period
170 --TODO: Create GC root so we're sure our closure won't go away during this time period
172 withSpinner "Switching to new configuration" $ ifor_ buildOutputByHost $ \host outputPath -> do
171 withSpinner "Switching to new configuration" $ ifor_ buildOutputByHost $ \host outputPath -> do
173 callProcessAndLogOutput (Notice, Warning) $
172 callProcessAndLogOutput (Notice, Warning) $
174− proc "ssh" $ sshOpts <>
173+ proc sshPath $ sshOpts <>
175 [ "root@" <> host
174 [ "root@" <> host
176 , unwords
175 , unwords
176+ -- Note that we don't want to $(staticWhich "nix-env") here, because this is executing on a remote machine
177 [ "nix-env -p /nix/var/nix/profiles/system --set " <> outputPath
177 [ "nix-env -p /nix/var/nix/profiles/system --set " <> outputPath
178 , "&&"
178 , "&&"
179 , "/nix/var/nix/profiles/system/bin/switch-to-configuration switch"
179 , "/nix/var/nix/profiles/system/bin/switch-to-configuration switch"
@@ -182,10 +182,10 @@ deployPush deployPath getNixBuilders = do
182 isClean <- checkGitCleanStatus deployPath True
182 isClean <- checkGitCleanStatus deployPath True
183 when (not isClean) $ do
183 when (not isClean) $ do
184 withSpinner "Committing changes to Git" $ do
184 withSpinner "Committing changes to Git" $ do
185− callProcessAndLogOutput (Debug, Error) $ proc "git"
185+ callProcessAndLogOutput (Debug, Error) $
186− ["-C", deployPath, "add", "."]
186+ gitProc deployPath ["add", "."]
187− callProcessAndLogOutput (Debug, Error) $ proc "git"
187+ callProcessAndLogOutput (Debug, Error) $
188− ["-C", deployPath, "commit", "-m", "New deployment"]
188+ gitProc deployPath ["commit", "-m", "New deployment"]
189 putLog Notice $ "Deployed => " <> T.pack route
189 putLog Notice $ "Deployed => " <> T.pack route
190 where
190 where
191 callProcess' envMap cmd args = do
191 callProcess' envMap cmd args = do
@@ -315,7 +315,7 @@ readDeployConfig deployDir fname = liftIO $ do
315
315
316verifyHostKey :: MonadObelisk m => FilePath -> FilePath -> String -> m ()
316verifyHostKey :: MonadObelisk m => FilePath -> FilePath -> String -> m ()
317verifyHostKey knownHostsPath keyPath hostName =
317verifyHostKey knownHostsPath keyPath hostName =
318− callProcessAndLogOutput (Notice, Warning) $ proc "ssh" $
318+ callProcessAndLogOutput (Notice, Warning) $ proc sshPath $
319 sshArgs knownHostsPath keyPath True <>
319 sshArgs knownHostsPath keyPath True <>
320 [ "root@" <> hostName
320 [ "root@" <> hostName
321 , "-o", "NumberOfPasswordPrompts=0"
321 , "-o", "NumberOfPasswordPrompts=0"
lib/command/src/Obelisk/Command/Preprocessor.hs+52−47
@@ -5,6 +5,7 @@ module Obelisk.Command.Preprocessor where
5
5
6import qualified Data.ByteString.Lazy as BL
6import qualified Data.ByteString.Lazy as BL
7import qualified Data.ByteString.Lazy.Builder as BU
7import qualified Data.ByteString.Lazy.Builder as BU
8+import Data.Foldable (for_)
8import Data.List (intersperse, isPrefixOf, sortOn)
9import Data.List (intersperse, isPrefixOf, sortOn)
9import Data.Maybe (fromMaybe)
10import Data.Maybe (fromMaybe)
10import qualified Data.Text.Lazy.Builder as TL
11import qualified Data.Text.Lazy.Builder as TL
@@ -17,79 +18,83 @@ import System.FilePath (hasTrailingPathSeparator, joinPath, splitPath)
17
18
18import Obelisk.Command.Run (CabalPackageInfo (..), parseCabalPackage')
19import Obelisk.Command.Run (CabalPackageInfo (..), parseCabalPackage')
19
20
21+-- | This code is intended to be executed via ghci's -pgmF preprocessor option.
22+-- The command line arguments are passed in via ghc, which dictates the first three options and meanings
23+-- In order for this code to execute, origPath must contain either a '.' character or a '/' character.
24+-- (This is to avoid the possibility of the command line syntax conflicting with another ob command)
25+-- We do have control over the remaining arguments, but they must be the same for all files.
26+-- Thus, the fourth command line argument must be "apply-packages", which has already been handled.
27+-- We assume all the remaining arguments passed in are paths to cabal or hpack package specifications.
28+-- Thus we must select among the packagePaths for the file we are going to parse.
20applyPackages :: FilePath -> FilePath -> FilePath -> [FilePath] -> IO ()
29applyPackages :: FilePath -> FilePath -> FilePath -> [FilePath] -> IO ()
21−applyPackages origPath inPath outPath packagePaths' = withFile outPath WriteMode $ \outFile -> do
30+applyPackages origPath inPath outPath packagePaths' = do
22− -- This code is intended to be executed via ghci's -pgmF preprocessor option
23− -- The command line arguments are passed in via ghc, which dictates the first three options and meanings
24− -- In order for this code to execute, origPath must contain either a '.' character or a '/' character.
25− -- (This is to avoid the possibility of the command line syntax conflicting with another ob command)
26− -- We do have control over the remaining arguments, but they must be the same for all files.
27− -- Thus, the fourth command line argument must be "apply-packages", which has already been handled.
28− -- We assume all the remaining arguments passed in are paths to cabal or hpack package specifications.
29− -- Thus we must select among the packagePaths for the file we are going to parse.
30−
31 origPathCanonical <- canonicalizePath origPath
31 origPathCanonical <- canonicalizePath origPath
32 packagePaths <- traverse canonicalizePath packagePaths'
32 packagePaths <- traverse canonicalizePath packagePaths'
33
33
34+ let
34− let takeDirs = takeWhile hasTrailingPathSeparator
35+ takeDirs = takeWhile hasTrailingPathSeparator
35− packageDirs = sortOn (negate . length . takeDirs) $ map splitPath packagePaths
36+ packageDirs = sortOn (negate . length . takeDirs) $ map splitPath packagePaths
36− origDir = splitPath origPathCanonical
37+ origDir = splitPath origPathCanonical
37− matches = [ joinPath d | d <- packageDirs, takeDirs d `isPrefixOf` origDir ]
38+ matches = [ joinPath d | d <- packageDirs, takeDirs d `isPrefixOf` origDir ]
38
39
39− -- So the first element of matches is going to be the deepest path to a package spec that contains
40+ -- The first element of matches is going to be the deepest path to a package spec that contains
40 -- our file as a subdirectory.
41 -- our file as a subdirectory.
41−
42− case matches of
42+ packageInfo' <- case matches of
43− [] ->
43+ [] -> do
44 hPutStrLn stderr $ "Error: Unable to find cabal information for " <> origPath <> "; Skipping preprocessor."
44 hPutStrLn stderr $ "Error: Unable to find cabal information for " <> origPath <> "; Skipping preprocessor."
45− packagePath:_ -> do
45+ pure Nothing
46− parseCabalPackage' packagePath >>= \case
46+ packagePath:_ -> parseCabalPackage' packagePath >>= \case
47− Left err ->
47+ Left err -> do
48− hPutStrLn stderr $ "Error: Unable to parse cabal package " <> packagePath <> "; Skipping preprocessor on " <> origPath <> ". Error: " <> show err
48+ hPutStrLn stderr $ "Error: Unable to parse cabal package " <> packagePath <> "; Skipping preprocessor on " <> origPath <> ". Error: " <> show err
49+ pure Nothing
49− Right (_warnings, packageInfo) ->
50+ Right (Just (_, packageInfo)) -> pure $ Just packageInfo
50− hPutTextBuilder outFile (generateHeader origPath packageInfo)
51+ Right Nothing -> pure Nothing
51
52
52− BL.readFile inPath >>= BL.hPut outFile
53+ writeOutput packageInfo' inPath outPath
53
54
55+writeOutput :: Maybe CabalPackageInfo -> FilePath -> FilePath -> IO ()
56+writeOutput packageInfo' origPath outPath = withFile outPath WriteMode $ \hOut -> do
57+ for_ packageInfo' $ \packageInfo -> hPutTextBuilder hOut (generateHeader origPath packageInfo)
58+ BL.readFile origPath >>= BL.hPut hOut
54 where
59 where
55 hPutTextBuilder h = BU.hPutBuilder h . TL.encodeUtf8Builder . TL.toLazyText
60 hPutTextBuilder h = BU.hPutBuilder h . TL.encodeUtf8Builder . TL.toLazyText
56
61
57−
58− -- I'm pretty sure there's a certain amount of oversimplification in CabalPackageInfo, so I doubt this is fully robust.
59−
60generateHeader :: FilePath -> CabalPackageInfo -> TL.Builder
62generateHeader :: FilePath -> CabalPackageInfo -> TL.Builder
61generateHeader origPath packageInfo =
63generateHeader origPath packageInfo =
62 hsExtensions <> ghcOptions <> lineNumberPragma origPath
64 hsExtensions <> ghcOptions <> lineNumberPragma origPath
63 where
65 where
64 hsExtensions =
66 hsExtensions =
65− if not (null extList)
67+ if null extList
66− then TL.fromText "{-# LANGUAGE "
68+ then mempty
67− <> mconcat (intersperse (TL.fromText ", ") extList)
69+ else pragma $ TL.fromText "LANGUAGE " <> mconcat (intersperse (TL.fromText ", ") extList)
68− <> TL.fromText " #-}\n"
69− else mempty
70 extList = addDefaultLanguage $ concatMap showExt $ _cabalPackageInfo_defaultExtensions packageInfo
70 extList = addDefaultLanguage $ concatMap showExt $ _cabalPackageInfo_defaultExtensions packageInfo
71 addDefaultLanguage =
71 addDefaultLanguage =
72 case _cabalPackageInfo_defaultLanguage packageInfo of
72 case _cabalPackageInfo_defaultLanguage packageInfo of
73 Nothing -> id
73 Nothing -> id
74 Just x -> case x of
74 Just x -> case x of
75− UnknownLanguage ext -> ( TL.fromString ext :)
75+ UnknownLanguage ext -> (TL.fromString ext :)
76− ext -> ( TL.fromString (show ext) :)
76+ ext -> (TL.fromString (show ext) :)
77 showExt = \case
77 showExt = \case
78 EnableExtension ext -> [TL.fromString (show ext)]
78 EnableExtension ext -> [TL.fromString (show ext)]
79− DisableExtension _ -> []
79+ DisableExtension ext -> ["No" <> TL.fromString (show ext)]
80 UnknownExtension ext -> [TL.fromString ext]
80 UnknownExtension ext -> [TL.fromString ext]
81
81
82 ghcOptions =
82 ghcOptions =
83− if not (null optList)
83+ if null optList
84− then TL.fromText "{-# OPTIONS_GHC "
84+ then mempty
85+ else pragma $
85− <> mconcat (intersperse (TL.fromText " ") optList)
86+ TL.fromText "OPTIONS_GHC " <> mconcat (intersperse (TL.fromText " ") (map TL.fromString optList))
86− <> TL.fromText " #-}\n"
87+ ghcOptList
87− else mempty
88− optList = map TL.fromString
89− $ filter (not . isPrefixOf "-O")
88+ = filter (not . isPrefixOf "-O")
90− $ fromMaybe []
89+ $ fromMaybe []
91− $ lookup GHC (_cabalPackageInfo_compilerOptions packageInfo)
90+ $ lookup GHC (_cabalPackageInfo_compilerOptions packageInfo)
91+ optList = _cabalPackageInfo_cppOptions packageInfo <> ghcOptList
92
92
93lineNumberPragma :: FilePath -> TL.Builder
93lineNumberPragma :: FilePath -> TL.Builder
94−lineNumberPragma origPath =
95− TL.fromText "{-# LINE 1 \"" <> TL.fromString origPath <> TL.fromText "\" #-}\n"
94+lineNumberPragma origPath = pragma $ TL.fromText "LINE 1 " <> quoted '"' (TL.fromString origPath)
95+
96+pragma :: TL.Builder -> TL.Builder
97+pragma x = TL.fromText "{-# " <> x <> TL.fromText " #-}\n"
98+
99+quoted :: Char -> TL.Builder -> TL.Builder
100+quoted char x = TL.singleton char <> x <> TL.singleton char
lib/command/src/Obelisk/Command/Project.hs+15−10
@@ -39,8 +39,9 @@ import System.Environment (lookupEnv)
39import System.FilePath
39import System.FilePath
40import System.IO.Temp
40import System.IO.Temp
41import System.IO.Unsafe (unsafePerformIO)
41import System.IO.Unsafe (unsafePerformIO)
42−import System.Posix (FileStatus, FileMode, CMode (..), UserID, deviceID, fileID, fileMode, fileOwner, getFileStatus, getRealUserID)
42+import System.PosixCompat.Files
43−import System.Posix.Files
43+import System.PosixCompat.Types
44+import System.PosixCompat.User
44import Text.ShellEscape (bash, bytes)
45import Text.ShellEscape (bash, bytes)
45
46
46import GitHub.Data.GitData (Branch)
47import GitHub.Data.GitData (Branch)
@@ -50,7 +51,7 @@ import Obelisk.App (MonadObelisk)
50import Obelisk.CliApp
51import Obelisk.CliApp
51import Obelisk.Command.Nix
52import Obelisk.Command.Nix
52import Obelisk.Command.Thunk
53import Obelisk.Command.Thunk
53−import Obelisk.Command.Utils (nixBuildExePath, nixExePath, toNixPath)
54+import Obelisk.Command.Utils (nixBuildExePath, nixExePath, toNixPath, cp, nixShellPath)
54
55
55--TODO: Make this module resilient to random exceptions
56--TODO: Make this module resilient to random exceptions
56
57
@@ -115,7 +116,7 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do
115 skel <- nixBuildAttrWithCache implDir "skeleton" --TODO: I don't think there's actually any reason to cache this
116 skel <- nixBuildAttrWithCache implDir "skeleton" --TODO: I don't think there's actually any reason to cache this
116
117
117 callProcessAndLogOutput (Notice, Error) $
118 callProcessAndLogOutput (Notice, Error) $
118− proc "cp"
119+ proc cp
119 [ "-r"
120 [ "-r"
120 , "--preserve=links"
121 , "--preserve=links"
121 , obDir
122 , obDir
@@ -125,7 +126,7 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do
125
126
126 withSpinner "Copying project skeleton" $ do
127 withSpinner "Copying project skeleton" $ do
127 callProcessAndLogOutput (Notice, Error) $
128 callProcessAndLogOutput (Notice, Error) $
128− proc "cp"
129+ proc cp
129 [ "-r"
130 [ "-r"
130 , "--no-preserve=mode"
131 , "--no-preserve=mode"
131 , "-T"
132 , "-T"
@@ -136,6 +137,12 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do
136 let configDir = "config"
137 let configDir = "config"
137 createDirectoryIfMissing False configDir
138 createDirectoryIfMissing False configDir
138 mapM_ (createDirectoryIfMissing False . (configDir </>)) ["backend", "common", "frontend"]
139 mapM_ (createDirectoryIfMissing False . (configDir </>)) ["backend", "common", "frontend"]
140+ putLog Notice $ T.intercalate "\n"
141+ [ "An obelisk project has been successfully initialized. Next steps:"
142+ , " 'ob run': Start a development server"
143+ , " 'ob watch': Watch for changes without starting a server"
144+ , " 'ob repl': Load your project into GHCi"
145+ ]
139
146
140callHandoffOb
147callHandoffOb
141 :: MonadObelisk m
148 :: MonadObelisk m
@@ -291,7 +298,7 @@ bashEscape :: String -> String
291bashEscape = BSU.toString . bytes . bash . BSU.fromString
298bashEscape = BSU.toString . bytes . bash . BSU.fromString
292
299
293nixShellRunProc :: NixShellConfig -> ProcessSpec
300nixShellRunProc :: NixShellConfig -> ProcessSpec
294−nixShellRunProc cfg = setDelegateCtlc True $ proc "nix-shell" $ runNixShellConfig cfg
301+nixShellRunProc cfg = setDelegateCtlc True $ proc nixShellPath $ runNixShellConfig cfg
295
302
296nixShellWithoutPkgs
303nixShellWithoutPkgs
297 :: MonadObelisk m
304 :: MonadObelisk m
@@ -306,7 +313,7 @@ nixShellWithoutPkgs root isPure chdirToRoot packageNamesAndPaths shellAttr comma
306 packageNamesAndAbsPaths <- liftIO $ for packageNamesAndPaths makeAbsolute
313 packageNamesAndAbsPaths <- liftIO $ for packageNamesAndPaths makeAbsolute
307 defShellConfig <- nixShellRunConfig root isPure command
314 defShellConfig <- nixShellRunConfig root isPure command
308 let setCwd_ = if chdirToRoot then setCwd (Just root) else id
315 let setCwd_ = if chdirToRoot then setCwd (Just root) else id
309− (_, _, _, ph) <- createProcess_ "nixShellWithoutPkgs" $ setCwd_ $ nixShellRunProc $ defShellConfig
316+ runProcess_ $ setCwd_ $ nixShellRunProc $ defShellConfig
310 & nixShellConfig_common . nixCmdConfig_target . target_expr ?~
317 & nixShellConfig_common . nixCmdConfig_target . target_expr ?~
311 "{root, pkgs, shell}: ((import root {}).passthru.__unstable__.self.extend (_: _: {\
318 "{root, pkgs, shell}: ((import root {}).passthru.__unstable__.self.extend (_: _: {\
312 \shellPackages = builtins.fromJSON pkgs;\
319 \shellPackages = builtins.fromJSON pkgs;\
@@ -316,18 +323,16 @@ nixShellWithoutPkgs root isPure chdirToRoot packageNamesAndPaths shellAttr comma
316 , strArg "pkgs" (T.unpack $ decodeUtf8 $ BSL.toStrict $ Json.encode packageNamesAndAbsPaths)
323 , strArg "pkgs" (T.unpack $ decodeUtf8 $ BSL.toStrict $ Json.encode packageNamesAndAbsPaths)
317 , strArg "shell" shellAttr
324 , strArg "shell" shellAttr
318 ]
325 ]
319− void $ waitForProcess ph
320
326
321nixShellWithHoogle :: MonadObelisk m => FilePath -> Bool -> String -> Maybe String -> m ()
327nixShellWithHoogle :: MonadObelisk m => FilePath -> Bool -> String -> Maybe String -> m ()
322nixShellWithHoogle root isPure shell' command = do
328nixShellWithHoogle root isPure shell' command = do
323 defShellConfig <- nixShellRunConfig root isPure command
329 defShellConfig <- nixShellRunConfig root isPure command
324− (_, _, _, ph) <- createProcess_ "nixShellWithHoogle" $ setCwd (Just root) $ nixShellRunProc $ defShellConfig
330+ runProcess_ $ setCwd (Just root) $ nixShellRunProc $ defShellConfig
325 & nixShellConfig_common . nixCmdConfig_target . target_expr ?~
331 & nixShellConfig_common . nixCmdConfig_target . target_expr ?~
326 "{shell}: ((import ./. {}).passthru.__unstable__.self.extend (_: super: {\
332 "{shell}: ((import ./. {}).passthru.__unstable__.self.extend (_: super: {\
327 \userSettings = super.userSettings // { withHoogle = true; };\
333 \userSettings = super.userSettings // { withHoogle = true; };\
328 \})).project.shells.${shell}"
334 \})).project.shells.${shell}"
329 & nixShellConfig_common . nixCmdConfig_args .~ [ strArg "shell" shell' ]
335 & nixShellConfig_common . nixCmdConfig_args .~ [ strArg "shell" shell' ]
330− void $ waitForProcess ph
331
336
332findProjectAssets :: MonadObelisk m => FilePath -> m Text
337findProjectAssets :: MonadObelisk m => FilePath -> m Text
333findProjectAssets root = do
338findProjectAssets root = do
lib/command/src/Obelisk/Command/Run.hs+61−46
@@ -14,7 +14,7 @@ module Obelisk.Command.Run where
14import Control.Arrow ((&&&))
14import Control.Arrow ((&&&))
15import Control.Exception (Exception, bracket)
15import Control.Exception (Exception, bracket)
16import Control.Lens (ifor, (.~), (&))
16import Control.Lens (ifor, (.~), (&))
17−import Control.Monad (filterM, unless, void)
17+import Control.Monad (filterM)
18import Control.Monad.Except (runExceptT, throwError)
18import Control.Monad.Except (runExceptT, throwError)
19import Control.Monad.IO.Class (liftIO)
19import Control.Monad.IO.Class (liftIO)
20import Control.Monad.Reader (MonadIO)
20import Control.Monad.Reader (MonadIO)
@@ -25,12 +25,14 @@ import Data.Default (def)
25import Data.Either (partitionEithers)
25import Data.Either (partitionEithers)
26import Data.Foldable (fold, for_, toList)
26import Data.Foldable (fold, for_, toList)
27import Data.Functor.Identity (runIdentity)
27import Data.Functor.Identity (runIdentity)
28+import Data.List (intercalate)
28import Data.List.NonEmpty (NonEmpty)
29import Data.List.NonEmpty (NonEmpty)
29import qualified Data.List.NonEmpty as NE
30import qualified Data.List.NonEmpty as NE
30import Data.Map (Map)
31import Data.Map (Map)
31import qualified Data.Map as Map
32import qualified Data.Map as Map
32import qualified Data.Map.Monoidal as MMap
33import qualified Data.Map.Monoidal as MMap
33−import Data.Maybe
34+import Data.Maybe (catMaybes, fromMaybe, mapMaybe)
35+import Data.Ord (comparing)
34import Data.Set (Set)
36import Data.Set (Set)
35import qualified Data.Set as Set
37import qualified Data.Set as Set
36import Data.String.Here.Interpolated (i)
38import Data.String.Here.Interpolated (i)
@@ -44,17 +46,17 @@ import Distribution.Compiler (CompilerFlavor(..))
44import Distribution.PackageDescription.Parsec (parseGenericPackageDescription)
46import Distribution.PackageDescription.Parsec (parseGenericPackageDescription)
45import Distribution.Parsec.ParseResult (runParseResult)
47import Distribution.Parsec.ParseResult (runParseResult)
46import qualified Distribution.System as Dist
48import qualified Distribution.System as Dist
47−import Distribution.Types.BuildInfo
49+import Distribution.Types.BuildInfo (buildable, cppOptions, defaultExtensions, defaultLanguage, hsSourceDirs, options)
48−import Distribution.Types.CondTree
50+import Distribution.Types.CondTree (simplifyCondTree)
49−import Distribution.Types.GenericPackageDescription
51+import Distribution.Types.GenericPackageDescription (ConfVar (Arch, Impl, OS), condLibrary)
50−import Distribution.Types.Library
52+import Distribution.Types.Library (libBuildInfo)
51−import Distribution.Utils.Generic
53+import Distribution.Utils.Generic (toUTF8BS, readUTF8File)
52import qualified Distribution.Parsec.Common as Dist
54import qualified Distribution.Parsec.Common as Dist
53import qualified Hpack.Config as Hpack
55import qualified Hpack.Config as Hpack
54import qualified Hpack.Render as Hpack
56import qualified Hpack.Render as Hpack
55import qualified Hpack.Yaml as Hpack
57import qualified Hpack.Yaml as Hpack
56−import Language.Haskell.Extension
58+import Language.Haskell.Extension (Extension, Language)
57−import Network.Socket hiding (Debug)
59+import qualified Network.Socket as Socket
58import System.Directory
60import System.Directory
59import System.Environment (getExecutablePath)
61import System.Environment (getExecutablePath)
60import System.FilePath
62import System.FilePath
@@ -64,15 +66,14 @@ import System.IO.Temp (withSystemTempDirectory)
64import Obelisk.App (MonadObelisk)
66import Obelisk.App (MonadObelisk)
65import Obelisk.CliApp (
67import Obelisk.CliApp (
66 Severity (..),
68 Severity (..),
67− createProcess_,
68 failWith,
69 failWith,
69 proc,
70 proc,
70 putLog,
71 putLog,
71 readCreateProcessWithExitCode,
72 readCreateProcessWithExitCode,
72 readProcessAndLogStderr,
73 readProcessAndLogStderr,
74+ runProcess_,
73 setCwd,
75 setCwd,
74 setDelegateCtlc,
76 setDelegateCtlc,
75− waitForProcess,
76 withSpinner,
77 withSpinner,
77 )
78 )
78import Obelisk.Command.Nix
79import Obelisk.Command.Nix
@@ -93,9 +94,11 @@ data CabalPackageInfo = CabalPackageInfo
93 -- ^ List of globally set languages of the library component
94 -- ^ List of globally set languages of the library component
94 , _cabalPackageInfo_compilerOptions :: [(CompilerFlavor, [String])]
95 , _cabalPackageInfo_compilerOptions :: [(CompilerFlavor, [String])]
95 -- ^ List of compiler-specific options (e.g., the "ghc-options" field of the cabal file)
96 -- ^ List of compiler-specific options (e.g., the "ghc-options" field of the cabal file)
97+ , _cabalPackageInfo_cppOptions :: [String]
98+ -- ^ List of CPP (C Preprocessor) options (e.g. the "cpp-options" field of the cabal file)
96 }
99 }
97
100
98−-- | 'Bool' with a better name for it's purpose.
101+-- | 'Bool' with a better name for its purpose.
99data Interpret = Interpret_Interpret | Interpret_NoInterpret deriving (Eq, Ord, Show)
102data Interpret = Interpret_Interpret | Interpret_NoInterpret deriving (Eq, Ord, Show)
100
103
101textInterpret :: Interpret -> Text
104textInterpret :: Interpret -> Text
@@ -148,7 +151,7 @@ profile profileBasePattern rtsFlags = withProjectRoot "." $ \root -> do
148 liftIO $ createDirectoryIfMissing True $ takeDirectory $ root </> profileBaseName
151 liftIO $ createDirectoryIfMissing True $ takeDirectory $ root </> profileBaseName
149 putLog Debug $ "Storing profiled data under base name of " <> T.pack (root </> profileBaseName)
152 putLog Debug $ "Storing profiled data under base name of " <> T.pack (root </> profileBaseName)
150 freePort <- getFreePort
153 freePort <- getFreePort
151− (_, _, _, ph) <- createProcess_ "runProfExe" $ setCwd (Just root) $ setDelegateCtlc True $ proc (outPath </> "bin" </> "ob-run") $
154+ runProcess_ $ setCwd (Just root) $ setDelegateCtlc True $ proc (outPath </> "bin" </> "ob-run") $
152 [ show freePort
155 [ show freePort
153 , T.unpack assets
156 , T.unpack assets
154 , profileBaseName
157 , profileBaseName
@@ -156,17 +159,16 @@ profile profileBasePattern rtsFlags = withProjectRoot "." $ \root -> do
156 , "-po" <> profileBaseName
159 , "-po" <> profileBaseName
157 ] <> rtsFlags
160 ] <> rtsFlags
158 <> [ "-RTS" ]
161 <> [ "-RTS" ]
159− void $ waitForProcess ph
160
162
161run :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()
163run :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()
162run root interpretPaths = do
164run root interpretPaths = do
163 pkgs <- getParsedLocalPkgs root interpretPaths
165 pkgs <- getParsedLocalPkgs root interpretPaths
164− withGhciScript pkgs $ \dotGhciPath -> do
165− assets <- findProjectAssets root
166+ assets <- findProjectAssets root
166− putLog Debug $ "Assets impurely loaded from: " <> assets
167+ putLog Debug $ "Assets impurely loaded from: " <> assets
167− ghciArgs <- getGhciSessionSettings pkgs root True
168+ ghciArgs <- getGhciSessionSettings pkgs root True
168− freePort <- getFreePort
169+ freePort <- getFreePort
170+ withGhciScriptArgs pkgs $ \dotGhciArgs -> do
169− runGhcid root True (ghciArgs <> mkGhciScriptArg dotGhciPath) pkgs $ Just $ unwords
171+ runGhcid root True (ghciArgs <> dotGhciArgs) pkgs $ Just $ unwords
170 [ "Obelisk.Run.run"
172 [ "Obelisk.Run.run"
171 , show freePort
173 , show freePort
172 , "(Obelisk.Run.runServeAsset " ++ show assets ++ ")"
174 , "(Obelisk.Run.runServeAsset " ++ show assets ++ ")"
@@ -178,15 +180,15 @@ runRepl :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()
178runRepl root interpretPaths = do
180runRepl root interpretPaths = do
179 pkgs <- getParsedLocalPkgs root interpretPaths
181 pkgs <- getParsedLocalPkgs root interpretPaths
180 ghciArgs <- getGhciSessionSettings pkgs "." True
182 ghciArgs <- getGhciSessionSettings pkgs "." True
181− withGhciScript pkgs $ \dotGhciPath ->
183+ withGhciScriptArgs pkgs $ \dotGhciArgs ->
182− runGhciRepl root pkgs (ghciArgs <> mkGhciScriptArg dotGhciPath)
184+ runGhciRepl root pkgs (ghciArgs <> dotGhciArgs)
183
185
184runWatch :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()
186runWatch :: MonadObelisk m => FilePath -> PathTree Interpret -> m ()
185runWatch root interpretPaths = do
187runWatch root interpretPaths = do
186 pkgs <- getParsedLocalPkgs root interpretPaths
188 pkgs <- getParsedLocalPkgs root interpretPaths
187 ghciArgs <- getGhciSessionSettings pkgs root True
189 ghciArgs <- getGhciSessionSettings pkgs root True
188− withGhciScript pkgs $ \dotGhciPath ->
190+ withGhciScriptArgs pkgs $ \dotGhciArgs ->
189− runGhcid root True (ghciArgs <> mkGhciScriptArg dotGhciPath) pkgs Nothing
191+ runGhcid root True (ghciArgs <> dotGhciArgs) pkgs Nothing
190
192
191exportGhciConfig :: MonadObelisk m => Bool -> FilePath -> PathTree Interpret -> m [String]
193exportGhciConfig :: MonadObelisk m => Bool -> FilePath -> PathTree Interpret -> m [String]
192exportGhciConfig useRelativePaths root interpretPaths = do
194exportGhciConfig useRelativePaths root interpretPaths = do
@@ -302,15 +304,16 @@ parseCabalPackage
302 -> m (Maybe CabalPackageInfo)
304 -> m (Maybe CabalPackageInfo)
303parseCabalPackage dir = parseCabalPackage' dir >>= \case
305parseCabalPackage dir = parseCabalPackage' dir >>= \case
304 Left err -> Nothing <$ putLog Error err
306 Left err -> Nothing <$ putLog Error err
305− Right (warnings, pkgInfo) -> do
307+ Right (Just (warnings, pkgInfo)) -> do
306 for_ warnings $ putLog Warning . T.pack . show
308 for_ warnings $ putLog Warning . T.pack . show
307 pure $ Just pkgInfo
309 pure $ Just pkgInfo
310+ Right Nothing -> pure Nothing
308
311
309-- | Like 'parseCabalPackage' but returns errors and warnings directly so as to avoid 'MonadObelisk'.
312-- | Like 'parseCabalPackage' but returns errors and warnings directly so as to avoid 'MonadObelisk'.
310parseCabalPackage'
313parseCabalPackage'
311 :: (MonadIO m)
314 :: (MonadIO m)
312 => FilePath -- ^ Package directory
315 => FilePath -- ^ Package directory
313− -> m (Either T.Text ([Dist.PWarning], CabalPackageInfo))
316+ -> m (Either T.Text (Maybe ([Dist.PWarning], CabalPackageInfo)))
314parseCabalPackage' pkg = runExceptT $ do
317parseCabalPackage' pkg = runExceptT $ do
315 (cabalContents, packageFile, packageName) <- guessCabalPackageFile pkg >>= \case
318 (cabalContents, packageFile, packageName) <- guessCabalPackageFile pkg >>= \case
316 Left GuessPackageFileError_NotFound -> throwError $ "No .cabal or package.yaml file found in " <> T.pack pkg
319 Left GuessPackageFileError_NotFound -> throwError $ "No .cabal or package.yaml file found in " <> T.pack pkg
@@ -338,7 +341,7 @@ parseCabalPackage' pkg = runExceptT $ do
338 case condLibrary <$> result of
341 case condLibrary <$> result of
339 Right (Just condLib) -> do
342 Right (Just condLib) -> do
340 let (_, lib) = simplifyCondTree evalConfVar condLib
343 let (_, lib) = simplifyCondTree evalConfVar condLib
341− pure $ (warnings,) $ CabalPackageInfo
344+ pure $ Just $ (warnings,) $ CabalPackageInfo
342 { _cabalPackageInfo_packageName = T.pack packageName
345 { _cabalPackageInfo_packageName = T.pack packageName
343 , _cabalPackageInfo_packageFile = packageFile
346 , _cabalPackageInfo_packageFile = packageFile
344 , _cabalPackageInfo_packageRoot = takeDirectory packageFile
347 , _cabalPackageInfo_packageRoot = takeDirectory packageFile
@@ -350,18 +353,19 @@ parseCabalPackage' pkg = runExceptT $ do
350 , _cabalPackageInfo_defaultLanguage =
353 , _cabalPackageInfo_defaultLanguage =
351 defaultLanguage $ libBuildInfo lib
354 defaultLanguage $ libBuildInfo lib
352 , _cabalPackageInfo_compilerOptions = options $ libBuildInfo lib
355 , _cabalPackageInfo_compilerOptions = options $ libBuildInfo lib
356+ , _cabalPackageInfo_cppOptions = cppOptions $ libBuildInfo lib
353 }
357 }
354− Right Nothing -> throwError "Haskell package has no library component"
358+ Right Nothing -> pure Nothing
355 Left (_, errors) ->
359 Left (_, errors) ->
356 throwError $ T.pack $ "Failed to parse " <> packageFile <> ":\n" <> unlines (map show errors)
360 throwError $ T.pack $ "Failed to parse " <> packageFile <> ":\n" <> unlines (map show errors)
357
361
358parsePackagesOrFail :: (MonadObelisk m, Foldable f) => f FilePath -> m (NE.NonEmpty CabalPackageInfo)
362parsePackagesOrFail :: (MonadObelisk m, Foldable f) => f FilePath -> m (NE.NonEmpty CabalPackageInfo)
359parsePackagesOrFail dirs' = do
363parsePackagesOrFail dirs' = do
360− (pkgDirErrs, packageInfos') <- fmap partitionEithers $ for dirs $ \dir -> do
364+ packageInfos' <- fmap catMaybes $ for dirs $ \dir -> do
361 flip fmap (parseCabalPackage dir) $ \case
365 flip fmap (parseCabalPackage dir) $ \case
362 Just packageInfo
366 Just packageInfo
363− | _cabalPackageInfo_buildable packageInfo -> Right packageInfo
367+ | _cabalPackageInfo_buildable packageInfo -> Just packageInfo
364− _ -> Left dir
368+ _ -> Nothing
365
369
366 -- Sort duplicate packages such that we prefer shorter paths, but fall back to alphabetical ordering.
370 -- Sort duplicate packages such that we prefer shorter paths, but fall back to alphabetical ordering.
367 let packagesByName = Map.map (NE.sortBy $ comparing $ \p -> let n = _cabalPackageInfo_packageFile p in (length n, n))
371 let packagesByName = Map.map (NE.sortBy $ comparing $ \p -> let n = _cabalPackageInfo_packageFile p in (length n, n))
@@ -383,9 +387,6 @@ parsePackagesOrFail dirs' = do
383 "No valid, buildable packages found" <> (if null dirs then "" else " in " <> intercalate ", " dirs)
387 "No valid, buildable packages found" <> (if null dirs then "" else " in " <> intercalate ", " dirs)
384 Just xs -> pure xs
388 Just xs -> pure xs
385
389
386− unless (null pkgDirErrs) $
387− putLog Warning $ T.pack $ "Failed to find buildable packages in " <> intercalate ", " pkgDirErrs
388−
389 pure packageInfos
390 pure packageInfos
390 where
391 where
391 dirs = toList dirs'
392 dirs = toList dirs'
@@ -393,13 +394,29 @@ parsePackagesOrFail dirs' = do
393packageInfoToNamePathMap :: Foldable f => f CabalPackageInfo -> Map Text FilePath
394packageInfoToNamePathMap :: Foldable f => f CabalPackageInfo -> Map Text FilePath
394packageInfoToNamePathMap = Map.fromList . map (_cabalPackageInfo_packageName &&& _cabalPackageInfo_packageRoot) . toList
395packageInfoToNamePathMap = Map.fromList . map (_cabalPackageInfo_packageName &&& _cabalPackageInfo_packageRoot) . toList
395
396
397+-- Like 'withGhciScript' but provides the precise ghci arguments to add to a ghci session
398+withGhciScriptArgs
399+ :: (MonadObelisk m, Foldable f)
400+ => f CabalPackageInfo -- ^ List of packages to load into ghci
401+ -> ([String] -> m ()) -- ^ Action to run with the extra ghci arguments
402+ -> m ()
403+withGhciScriptArgs packageInfos f = withGhciScript loadPreludeManually packageInfos $ \fp -> f ["-XNoImplicitPrelude", "-ghci-script", fp]
404+ where
405+ -- These lines must be first and allow the session to support a custom Prelude when @-XNoImplicitPrelude@
406+ -- is passed to the ghci session.
407+ loadPreludeManually =
408+ [ ":add Prelude" -- @:add@ is used because it's less noisy when there is no custom Prelude
409+ , ":set -XImplicitPrelude" -- Turn the default setting on
410+ ]
411+
396-- | Create ghci configuration to load the given packages
412-- | Create ghci configuration to load the given packages
397withGhciScript
413withGhciScript
398 :: (MonadObelisk m, Foldable f)
414 :: (MonadObelisk m, Foldable f)
415+ => [String] -- ^ Commands to prefix to file
399− => f CabalPackageInfo -- ^ List of packages to load into ghci
416+ -> f CabalPackageInfo -- ^ List of packages to load into ghci
400 -> (FilePath -> m ()) -- ^ Action to run with the path to generated temporary .ghci
417 -> (FilePath -> m ()) -- ^ Action to run with the path to generated temporary .ghci
401 -> m ()
418 -> m ()
402−withGhciScript (toList -> packageInfos) f =
419+withGhciScript preCommands (toList -> packageInfos) f =
403 withSystemTempDirectory "ob-ghci" $ \fp -> do
420 withSystemTempDirectory "ob-ghci" $ \fp -> do
404 let dotGhciPath = fp </> ".ghci"
421 let dotGhciPath = fp </> ".ghci"
405 liftIO $ writeFile dotGhciPath dotGhci
422 liftIO $ writeFile dotGhciPath dotGhci
@@ -411,7 +428,8 @@ withGhciScript (toList -> packageInfos) f =
411 , [ "Backend" | "backend" `Set.member` packageNames ]
428 , [ "Backend" | "backend" `Set.member` packageNames ]
412 , [ "Frontend" | "frontend" `Set.member` packageNames ]
429 , [ "Frontend" | "frontend" `Set.member` packageNames ]
413 ]
430 ]
414− dotGhci = unlines
431+ dotGhci = unlines $
432+ preCommands <>
415 [ if null modulesToLoad then "" else ":load " <> unwords modulesToLoad
433 [ if null modulesToLoad then "" else ":load " <> unwords modulesToLoad
416 , "import qualified Obelisk.Run"
434 , "import qualified Obelisk.Run"
417 , "import qualified Frontend"
435 , "import qualified Frontend"
@@ -491,17 +509,14 @@ runGhcid root chdirToRoot ghciArgs (toList -> packages) mcmd =
491 reloadFiles = map adjustRoot [root </> "config"]
509 reloadFiles = map adjustRoot [root </> "config"]
492 restartFiles = map (adjustRoot . _cabalPackageInfo_packageFile) packages
510 restartFiles = map (adjustRoot . _cabalPackageInfo_packageFile) packages
493
511
494−mkGhciScriptArg :: FilePath -> [String]
495−mkGhciScriptArg dotGhci = ["-ghci-script", dotGhci]
496−
497−getFreePort :: MonadIO m => m PortNumber
512+getFreePort :: MonadIO m => m Socket.PortNumber
498−getFreePort = liftIO $ withSocketsDo $ do
513+getFreePort = liftIO $ Socket.withSocketsDo $ do
499− addr:_ <- getAddrInfo (Just defaultHints) (Just "127.0.0.1") (Just "0")
514+ addr:_ <- Socket.getAddrInfo (Just Socket.defaultHints) (Just "127.0.0.1") (Just "0")
500− bracket (open addr) close socketPort
515+ bracket (open addr) Socket.close Socket.socketPort
501 where
516 where
502 open addr = do
517 open addr = do
503− sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
518+ sock <- Socket.socket (Socket.addrFamily addr) (Socket.addrSocketType addr) (Socket.addrProtocol addr)
504− bind sock (addrAddress addr)
519+ Socket.bind sock (Socket.addrAddress addr)
505 return sock
520 return sock
506
521
507
522
lib/command/src/Obelisk/Command/Thunk.hs+3−3
@@ -56,7 +56,7 @@ import System.Exit
56import System.FilePath
56import System.FilePath
57import System.IO.Error
57import System.IO.Error
58import System.IO.Temp
58import System.IO.Temp
59−import System.Posix (getSymbolicLinkStatus, modificationTime)
59+import System.PosixCompat.Files (getSymbolicLinkStatus, modificationTime)
60import qualified Text.URI as URI
60import qualified Text.URI as URI
61
61
62import Obelisk.App (MonadObelisk)
62import Obelisk.App (MonadObelisk)
@@ -178,14 +178,14 @@ getNixSha256ForUriUnpacked
178getNixSha256ForUriUnpacked uri =
178getNixSha256ForUriUnpacked uri =
179 withExitFailMessage ("nix-prefetch-url: Failed to determine sha256 hash of URL " <> gitUriToText uri) $ do
179 withExitFailMessage ("nix-prefetch-url: Failed to determine sha256 hash of URL " <> gitUriToText uri) $ do
180 [hash] <- fmap T.lines $ readProcessAndLogOutput (Debug, Debug) $
180 [hash] <- fmap T.lines $ readProcessAndLogOutput (Debug, Debug) $
181− proc "nix-prefetch-url" ["--unpack", "--type", "sha256", T.unpack $ gitUriToText uri]
181+ proc nixPrefetchUrlPath ["--unpack", "--type", "sha256", T.unpack $ gitUriToText uri]
182 pure hash
182 pure hash
183
183
184nixPrefetchGit :: MonadObelisk m => GitUri -> Text -> Bool -> m NixSha256
184nixPrefetchGit :: MonadObelisk m => GitUri -> Text -> Bool -> m NixSha256
185nixPrefetchGit uri rev fetchSubmodules =
185nixPrefetchGit uri rev fetchSubmodules =
186 withExitFailMessage ("nix-prefetch-git: Failed to determine sha256 hash of Git repo " <> gitUriToText uri <> " at " <> rev) $ do
186 withExitFailMessage ("nix-prefetch-git: Failed to determine sha256 hash of Git repo " <> gitUriToText uri <> " at " <> rev) $ do
187 out <- readProcessAndLogStderr Debug $
187 out <- readProcessAndLogStderr Debug $
188− proc "nix-prefetch-git" $ filter (/="")
188+ proc nixPrefetchGitPath $ filter (/="")
189 [ "--url", T.unpack $ gitUriToText uri
189 [ "--url", T.unpack $ gitUriToText uri
190 , "--rev", T.unpack rev
190 , "--rev", T.unpack rev
191 , if fetchSubmodules then "--fetch-submodules" else ""
191 , if fetchSubmodules then "--fetch-submodules" else ""
lib/command/src/Obelisk/Command/Utils.hs+34−2
@@ -54,6 +54,38 @@ nixBuildExePath = $(staticWhich "nix-build")
54jreKeyToolPath :: FilePath
54jreKeyToolPath :: FilePath
55jreKeyToolPath = $(staticWhich "keytool")
55jreKeyToolPath = $(staticWhich "keytool")
56
56
57+nixPrefetchGitPath :: FilePath
58+nixPrefetchGitPath = $(staticWhich "nix-prefetch-git")
59+
60+nixPrefetchUrlPath :: FilePath
61+nixPrefetchUrlPath = $(staticWhich "nix-prefetch-url")
62+
63+nixShellPath :: FilePath
64+nixShellPath = $(staticWhich "nix-shell")
65+
66+rsyncPath :: FilePath
67+rsyncPath = $(staticWhich "rsync")
68+
69+sshPath :: FilePath
70+sshPath = $(staticWhich "ssh")
71+
72+gitPath :: FilePath
73+gitPath = $(staticWhich "git")
74+
75+whichPath :: FilePath
76+whichPath = $(staticWhich "which")
77+
78+sshKeygenPath :: FilePath
79+sshKeygenPath = $(staticWhich "ssh-keygen")
80+
81+-- $(staticWhich "docker") was intentionally omitted, at least for now
82+-- One concern is that I don't know how particular docker is about having the
83+-- CLI exe match the version of the docker daemon, which is largely outside of
84+-- the control of obelisk-command.
85+-- TODO: Investigate the tradeoffs associated with this choice
86+dockerPath :: FilePath
87+dockerPath = "docker"
88+
57-- | Nix syntax requires relative paths to be prefixed by @./@ or
89-- | Nix syntax requires relative paths to be prefixed by @./@ or
58-- @../@. This will make a 'FilePath' that can be embedded in a Nix
90-- @../@. This will make a 'FilePath' that can be embedded in a Nix
59-- expression.
91-- expression.
@@ -91,7 +123,7 @@ initGit repo = do
91 git ["commit", "-m", "Initial commit."]
123 git ["commit", "-m", "Initial commit."]
92
124
93gitProcNoRepo :: [String] -> ProcessSpec
125gitProcNoRepo :: [String] -> ProcessSpec
94−gitProcNoRepo args = setEnvOverride (M.singleton "GIT_TERMINAL_PROMPT" "0" <>) $ proc "git" args
126+gitProcNoRepo args = setEnvOverride (M.singleton "GIT_TERMINAL_PROMPT" "0" <>) $ proc gitPath args
95
127
96gitProc :: FilePath -> [String] -> ProcessSpec
128gitProc :: FilePath -> [String] -> ProcessSpec
97gitProc repo = gitProcNoRepo . runGitInDir
129gitProc repo = gitProcNoRepo . runGitInDir
@@ -108,7 +140,7 @@ isolateGitProc = setEnvOverride (overrides <>)
108 , ("GIT_CONFIG_NOSYSTEM", "1")
140 , ("GIT_CONFIG_NOSYSTEM", "1")
109 , ("GIT_TERMINAL_PROMPT", "0") -- git 2.3+
141 , ("GIT_TERMINAL_PROMPT", "0") -- git 2.3+
110 , ("GIT_ASKPASS", "echo") -- pre git 2.3 to just use empty password
142 , ("GIT_ASKPASS", "echo") -- pre git 2.3 to just use empty password
111− , ("GIT_SSH_COMMAND", "ssh -o PreferredAuthentications password -o PubkeyAuthentication no -o GSSAPIAuthentication no")
143+ , ("GIT_SSH_COMMAND", "ssh -o PreferredAuthentications=password -o PubkeyAuthentication=no -o GSSAPIAuthentication=no")
112 ]
144 ]
113
145
114-- | Recursively copy a directory using `cp -a` -- TODO: Should use -rT instead of -a
146-- | Recursively copy a directory using `cp -a` -- TODO: Should use -rT instead of -a
lib/command/src/Obelisk/Command/VmBuilder.hs+8−8
@@ -21,7 +21,7 @@ import qualified System.Info
21
21
22import Obelisk.App (MonadObelisk, getObeliskUserStateDir)
22import Obelisk.App (MonadObelisk, getObeliskUserStateDir)
23import Obelisk.CliApp
23import Obelisk.CliApp
24−import Obelisk.Command.Utils (rmPath)
24+import Obelisk.Command.Utils (rmPath, whichPath, sshKeygenPath, nixBuildExePath, dockerPath)
25
25
26-- | Generate the `--builders` argument string to enable the VM builder after ensuring it is available.
26-- | Generate the `--builders` argument string to enable the VM builder after ensuring it is available.
27getNixBuildersArg :: MonadObelisk m => m String
27getNixBuildersArg :: MonadObelisk m => m String
@@ -35,7 +35,7 @@ getNixBuildersArg = do
35
35
36checkForNixDarwin :: MonadObelisk m => String -> m ()
36checkForNixDarwin :: MonadObelisk m => String -> m ()
37checkForNixDarwin sshIdFile = do
37checkForNixDarwin sshIdFile = do
38− (exitCode, _, _) <- readCreateProcessWithExitCode $ proc "which" ["darwin-rebuild"]
38+ (exitCode, _, _) <- readCreateProcessWithExitCode $ proc whichPath ["darwin-rebuild"]
39 unless (exitCode == ExitSuccess) $ failWith $ T.intercalate "\n"
39 unless (exitCode == ExitSuccess) $ failWith $ T.intercalate "\n"
40 [ "Deployments from macOS require nix-darwin to be installed."
40 [ "Deployments from macOS require nix-darwin to be installed."
41 , "Follow the installation instructions here: https://github.com/LnL7/nix-darwin"
41 , "Follow the installation instructions here: https://github.com/LnL7/nix-darwin"
@@ -67,7 +67,7 @@ containerExists :: MonadObelisk m => FilePath -> m Bool
67containerExists stateDir = handle (\(_ :: IOError) -> failWith needDockerMsg) $ do
67containerExists stateDir = handle (\(_ :: IOError) -> failWith needDockerMsg) $ do
68 containerNames <- fmap (map T.strip . T.lines) $
68 containerNames <- fmap (map T.strip . T.lines) $
69 readProcessAndLogStderr Error $
69 readProcessAndLogStderr Error $
70− proc "docker" ["container", "list", "--all", "--format", "{{.Names}}"]
70+ proc dockerPath ["container", "list", "--all", "--format", "{{.Names}}"]
71 let exists = containerName `elem` containerNames
71 let exists = containerName `elem` containerNames
72 when exists $ testLinuxBuild stateDir
72 when exists $ testLinuxBuild stateDir
73 pure exists
73 pure exists
@@ -85,7 +85,7 @@ containerSshPort = 2222
85startContainer :: MonadObelisk m => m ()
85startContainer :: MonadObelisk m => m ()
86startContainer = withSpinner "Starting VM builder" $
86startContainer = withSpinner "Starting VM builder" $
87 callProcessAndLogOutput (Debug, Debug) $
87 callProcessAndLogOutput (Debug, Debug) $
88− proc "docker" ["start", containerName]
88+ proc dockerPath ["start", containerName]
89
89
90-- | Creates the Docker container; assumes it does not exist.
90-- | Creates the Docker container; assumes it does not exist.
91setupNixDocker :: MonadObelisk m => FilePath -> m ()
91setupNixDocker :: MonadObelisk m => FilePath -> m ()
@@ -98,12 +98,12 @@ setupNixDocker stateDir = withSpinner ("Creating Docker container named " <> con
98 callProcessAndLogOutput (Debug, Error) $
98 callProcessAndLogOutput (Debug, Error) $
99 proc rmPath ["-f", stateDir </> sshKeyFileName, stateDir </> sshKeyFileName <.> "pub"]
99 proc rmPath ["-f", stateDir </> sshKeyFileName, stateDir </> sshKeyFileName <.> "pub"]
100 callProcessAndLogOutput (Debug, Error) $
100 callProcessAndLogOutput (Debug, Error) $
101− proc "ssh-keygen" ["-t", "ed25519", "-f", stateDir </> sshKeyFileName, "-P", ""]
101+ proc sshKeygenPath ["-t", "ed25519", "-f", stateDir </> sshKeyFileName, "-P", ""]
102
102
103 -- Build the docker container (which uses the SSH keys in the 'ssh' folder)
103 -- Build the docker container (which uses the SSH keys in the 'ssh' folder)
104 containerId <- fmap T.strip $ readProcessAndLogStderr Error $
104 containerId <- fmap T.strip $ readProcessAndLogStderr Error $
105− proc "docker" ["build", stateDir, "--quiet"]
105+ proc dockerPath ["build", stateDir, "--quiet"]
106− callProcessAndLogOutput (Debug, Error) $ proc "docker"
106+ callProcessAndLogOutput (Debug, Error) $ proc dockerPath
107 [ "run"
107 [ "run"
108 , "--restart", "always"
108 , "--restart", "always"
109 , "--detach"
109 , "--detach"
@@ -155,7 +155,7 @@ testLinuxBuild :: MonadObelisk m => FilePath -> m ()
155testLinuxBuild stateDir
155testLinuxBuild stateDir
156 | System.Info.os == "linux" = failWith "Using the docker builder is not necessary on linux."
156 | System.Info.os == "linux" = failWith "Using the docker builder is not necessary on linux."
157 | otherwise = do
157 | otherwise = do
158− (exitCode, _stdout, stderr) <- readCreateProcessWithExitCode $ proc "nix-build"
158+ (exitCode, _stdout, stderr) <- readCreateProcessWithExitCode $ proc nixBuildExePath
159 [ "--no-out-link"
159 [ "--no-out-link"
160 , "-E", "(import <nixpkgs> { system = \"x86_64-linux\"; }).writeText \"test\" builtins.currentTime"
160 , "-E", "(import <nixpkgs> { system = \"x86_64-linux\"; }).writeText \"test\" builtins.currentTime"
161 , "--builders", nixBuildersArgString stateDir
161 , "--builders", nixBuildersArgString stateDir
lib/executable-config/default.nix+13−2
@@ -25,8 +25,19 @@ let
25in
25in
26
26
27{
27{
28− haskellOverlay = self: super: {
28+ haskellOverlay = self: super:
29+ let
30+ pkgs = self.callPackage ({pkgs}: pkgs) {};
31+ in {
32+ obelisk-executable-config-lookup = pkgs.haskell.lib.overrideCabal
29− obelisk-executable-config-lookup = self.callCabal2nix "obelisk-executable-config-lookup" (obeliskCleanSource ./lookup) {};
33+ (self.callCabal2nix "obelisk-executable-config-lookup" (obeliskCleanSource ./lookup) {})
34+ (drv: {
35+ # Hack until https://github.com/NixOS/cabal2nix/pull/432 lands
36+ libraryHaskellDepends = (drv.libraryHaskellDepends or [])
37+ ++ pkgs.stdenv.lib.optionals (with pkgs.stdenv.hostPlatform; isAndroid && is32bit) [
38+ self.android-activity
39+ ];
40+ });
30 };
41 };
31
42
32 platforms = {
43 platforms = {
lib/executable-config/inject/obelisk-executable-config-inject.cabal+1−1
@@ -15,4 +15,4 @@ library
15 text
15 text
16
16
17 exposed-modules: Obelisk.ExecutableConfig.Inject
17 exposed-modules: Obelisk.ExecutableConfig.Inject
18− ghc-options: -Wall
18+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/executable-config/lookup/obelisk-executable-config-lookup.cabal+10−7
@@ -31,15 +31,18 @@ library
31 base64-bytestring,
31 base64-bytestring,
32 bytestring,
32 bytestring,
33 containers,
33 containers,
34+ exceptions,
34 filepath,
35 filepath,
35− text,
36+ jsaddle,
36− transformers,
37+ mmorph,
37− transformers-base,
38− ref-tf,
39− primitive,
40 monad-control,
38 monad-control,
39+ mtl,
40+ primitive,
41+ ref-tf,
42+ reflex-dom-core,
41 reflex,
43 reflex,
42− reflex-dom,
44+ text,
43− jsaddle
45+ transformers-base,
46+ transformers
44
47
45 ghc-options: -Wall
48 ghc-options: -Wall
lib/executable-config/lookup/src/Obelisk/Configs.hs+31−12
@@ -18,24 +18,38 @@ module Obelisk.Configs
18 , getTextConfig
18 , getTextConfig
19 ) where
19 ) where
20
20
21−import Control.Applicative
21+import Control.Applicative (Alternative)
22−import Control.Monad
22+import Control.Monad (MonadPlus)
23−import Control.Monad.Base
23+import Control.Monad.Base (MonadBase)
24+import Control.Monad.Catch (MonadThrow)
25+import Control.Monad.Fail (MonadFail)
24−import Control.Monad.Fix
26+import Control.Monad.Fix (MonadFix)
27+import Control.Monad.IO.Class (MonadIO)
28+import Control.Monad.Morph (MFunctor)
25−import Control.Monad.Primitive
29+import Control.Monad.Primitive (PrimMonad, PrimState, primitive)
26−import Control.Monad.Ref
30+import Control.Monad.Ref (MonadRef)
27−import Control.Monad.IO.Class
28−import Control.Monad.Trans.Class
31+import Control.Monad.Trans (MonadTrans, lift)
29−import Control.Monad.Trans.Control
32+import Control.Monad.Trans.Control (MonadBaseControl)
30−import Control.Monad.Trans.Reader
33+import Control.Monad.Trans.Reader (ReaderT (..), ask, mapReaderT)
34+import Control.Monad.Trans.State (StateT)
35+import qualified Control.Monad.Trans.State.Strict as Strict
31import Data.ByteString (ByteString)
36import Data.ByteString (ByteString)
32import Data.Map (Map)
37import Data.Map (Map)
33import qualified Data.Map as Map
38import qualified Data.Map as Map
34import Data.Text (Text)
39import Data.Text (Text)
35import qualified Data.Text.Encoding as T
40import qualified Data.Text.Encoding as T
36import Reflex
41import Reflex
37−import Reflex.Host.Class
42+import Reflex.Host.Class (MonadReflexCreateTrigger)
38−import Reflex.Dom
43+import Reflex.Dom.Core
44+ ( DomBuilder
45+ , DomRenderHook
46+ , HasDocument
47+ , HasJS
48+ , HasJSContext
49+ , Prerender (Client)
50+ , StaticDomBuilderT
51+ , prerender
52+ )
39#ifndef ghcjs_HOST_OS
53#ifndef ghcjs_HOST_OS
40import Language.Javascript.JSaddle (MonadJSM)
54import Language.Javascript.JSaddle (MonadJSM)
41#endif
55#endif
@@ -62,6 +76,8 @@ instance HasConfigs m => HasConfigs (PostBuildT t m)
62instance HasConfigs m => HasConfigs (QueryT t q m)
76instance HasConfigs m => HasConfigs (QueryT t q m)
63instance HasConfigs m => HasConfigs (ReaderT r m)
77instance HasConfigs m => HasConfigs (ReaderT r m)
64instance HasConfigs m => HasConfigs (RequesterT t request response m)
78instance HasConfigs m => HasConfigs (RequesterT t request response m)
79+instance HasConfigs m => HasConfigs (StateT w m)
80+instance HasConfigs m => HasConfigs (Strict.StateT w m)
65instance HasConfigs m => HasConfigs (StaticDomBuilderT t m)
81instance HasConfigs m => HasConfigs (StaticDomBuilderT t m)
66instance HasConfigs m => HasConfigs (TriggerEventT t m)
82instance HasConfigs m => HasConfigs (TriggerEventT t m)
67
83
@@ -72,12 +88,15 @@ newtype ConfigsT m a = ConfigsT { unConfigsT :: ReaderT (Map Text ByteString) m
72 , Monad
88 , Monad
73 , MonadPlus
89 , MonadPlus
74 , Alternative
90 , Alternative
91+ , MonadFail
75 , MonadFix
92 , MonadFix
93+ , MonadThrow
76 , MonadIO
94 , MonadIO
77 , MonadBase m'
95 , MonadBase m'
78 , MonadBaseControl m'
96 , MonadBaseControl m'
79 , MonadRef
97 , MonadRef
80 , MonadTrans
98 , MonadTrans
99+ , MFunctor
81 , DomBuilder t
100 , DomBuilder t
82 , MonadHold t
101 , MonadHold t
83 , MonadReflexCreateTrigger t
102 , MonadReflexCreateTrigger t
lib/frontend/obelisk-frontend.cabal+1−1
@@ -26,4 +26,4 @@ library
26 exposed-modules:
26 exposed-modules:
27 Obelisk.Frontend
27 Obelisk.Frontend
28 Obelisk.Frontend.Cookie
28 Obelisk.Frontend.Cookie
29− ghc-options: -Wall
29+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/route/README.mdnew file+6
@@ -0,0 +1,6 @@
1+# obelisk-route
2+
3+[![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)](http://www.haskell.org)
4+[![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)](https://github.com/obsidiansystems/obelisk/blob/master/LICENSE)
5+
6+Robust URL management for single-page apps.
lib/route/obelisk-route.cabal+2−1
@@ -20,6 +20,7 @@ library
20 http-types,
20 http-types,
21 jsaddle,
21 jsaddle,
22 lens,
22 lens,
23+ mmorph,
23 monad-control,
24 monad-control,
24 mtl,
25 mtl,
25 network-uri,
26 network-uri,
@@ -38,4 +39,4 @@ library
38 exposed-modules: Obelisk.Route
39 exposed-modules: Obelisk.Route
39 Obelisk.Route.TH
40 Obelisk.Route.TH
40 Obelisk.Route.Frontend
41 Obelisk.Route.Frontend
41− ghc-options: -Wall -fwarn-redundant-constraints
42+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/route/src/Obelisk/Route.hs+36−22
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
1{-# LANGUAGE ApplicativeDo #-}
2{-# LANGUAGE ApplicativeDo #-}
2{-# LANGUAGE ConstraintKinds #-}
3{-# LANGUAGE ConstraintKinds #-}
3{-# LANGUAGE EmptyCase #-}
4{-# LANGUAGE EmptyCase #-}
@@ -5,7 +6,6 @@
5{-# LANGUAGE FlexibleContexts #-}
6{-# LANGUAGE FlexibleContexts #-}
6{-# LANGUAGE FlexibleInstances #-}
7{-# LANGUAGE FlexibleInstances #-}
7{-# LANGUAGE GADTs #-}
8{-# LANGUAGE GADTs #-}
8−{-# LANGUAGE KindSignatures #-}
9{-# LANGUAGE LambdaCase #-}
9{-# LANGUAGE LambdaCase #-}
10{-# LANGUAGE MultiParamTypeClasses #-}
10{-# LANGUAGE MultiParamTypeClasses #-}
11{-# LANGUAGE OverloadedStrings #-}
11{-# LANGUAGE OverloadedStrings #-}
@@ -140,16 +140,19 @@ import Control.Lens
140 , Wrapped (..)
140 , Wrapped (..)
141 )
141 )
142import Control.Monad.Except
142import Control.Monad.Except
143−import Control.Monad.Writer (execWriter, tell)
144import qualified Control.Monad.State.Strict as State
143import qualified Control.Monad.State.Strict as State
145import Control.Monad.Trans (lift)
144import Control.Monad.Trans (lift)
145+import Control.Monad.Writer (execWriter, tell)
146+import Data.Aeson (FromJSON, ToJSON)
147+import qualified Data.Aeson as Aeson
146import qualified Data.ByteString as BS
148import qualified Data.ByteString as BS
147import qualified Data.ByteString.Lazy as BSL
149import qualified Data.ByteString.Lazy as BSL
148−import Data.Dependent.Sum (DSum (..))
149import Data.Dependent.Map (DMap)
150import Data.Dependent.Map (DMap)
150import qualified Data.Dependent.Map as DMap
151import qualified Data.Dependent.Map as DMap
152+import Data.Dependent.Sum (DSum (..))
151import Data.Either.Validation (Validation (..))
153import Data.Either.Validation (Validation (..))
152import Data.Foldable
154import Data.Foldable
155+import Data.Functor (($>))
153import Data.Functor.Sum
156import Data.Functor.Sum
154import Data.GADT.Compare
157import Data.GADT.Compare
155import Data.GADT.Compare.TH
158import Data.GADT.Compare.TH
@@ -162,19 +165,18 @@ import Data.Monoid ((<>))
162import Data.Set (Set)
165import Data.Set (Set)
163import qualified Data.Set as Set
166import qualified Data.Set as Set
164import Data.Some (Some(Some))
167import Data.Some (Some(Some))
168+import Data.Tabulation
165import Data.Text (Text)
169import Data.Text (Text)
166−import Data.Text.Lens (IsText, packed, unpacked)
167import qualified Data.Text as T
170import qualified Data.Text as T
168import qualified Data.Text.Encoding as T
171import qualified Data.Text.Encoding as T
172+import Data.Text.Lens (IsText, packed, unpacked)
173+import Data.Type.Equality
169import Data.Universe
174import Data.Universe
170import Data.Universe.Some
175import Data.Universe.Some
171import Network.HTTP.Types.URI
176import Network.HTTP.Types.URI
172import qualified Numeric.Lens
177import qualified Numeric.Lens
173import Obelisk.Route.TH
178import Obelisk.Route.TH
174import Text.Read (readMaybe)
179import Text.Read (readMaybe)
175−import Data.Tabulation
176−import qualified Data.Aeson as Aeson
177−import Data.Aeson (FromJSON, ToJSON)
178
180
179-- Design goals:
181-- Design goals:
180-- No start-up time on the frontend (not yet met)
182-- No start-up time on the frontend (not yet met)
@@ -224,7 +226,19 @@ hoistR f (x :=> Identity y) = f x :/ y
224infixr 5 :.
226infixr 5 :.
225type (:.) = (,)
227type (:.) = (,)
226
228
229+#ifdef __GLASGOW_HASKELL__
230+#if __GLASGOW_HASKELL__ >= 810
227{-# COMPLETE (:.) #-}
231{-# COMPLETE (:.) #-}
232+#else
233+{-# WARNING (:.)
234+ [ "Use of this pattern in GHC < 8.10 will result in spurious non-exhaustive warnings at every use site."
235+ , "We cannot provide a COMPLETE pragma to silence these due to a GHC bug: https://gitlab.haskell.org/ghc/ghc/issues/17729."
236+ , "The bug hides incompleteness warnings for all two tuples when the COMPLETE pattern is in scope."
237+ , "Instead, you should use (,) directly until you can switch to GHC >= 8.10, where the COMPLETE pragma is reinstated."
238+ ]
239+ #-}
240+#endif
241+#endif
228pattern (:.) :: a -> b -> a :. b
242pattern (:.) :: a -> b -> a :. b
229pattern a :. b = (a, b)
243pattern a :. b = (a, b)
230
244
@@ -290,13 +304,13 @@ decode e x = runIdentity (tryDecode e x)
290-- | Once an 'Encoder' has been checked, so that its check monad has become 'Identity', even if the same is not true of the
304-- | Once an 'Encoder' has been checked, so that its check monad has become 'Identity', even if the same is not true of the
291-- parse monad, we may still attempt to decode with it in its parse monad.
305-- parse monad, we may still attempt to decode with it in its parse monad.
292tryDecode :: Encoder Identity parse decoded encoded -> encoded -> parse decoded
306tryDecode :: Encoder Identity parse decoded encoded -> encoded -> parse decoded
293−tryDecode (Encoder (Identity impl)) x = _encoderImpl_decode impl x
307+tryDecode (Encoder (Identity impl)) = _encoderImpl_decode impl
294
308
295-- | Similar to 'decode', once an encoder has been checked so that its check monad is Identity, it
309-- | Similar to 'decode', once an encoder has been checked so that its check monad is Identity, it
296-- can be used to actually encode by using this. Note that while there's no constraint on the parse monad here,
310-- can be used to actually encode by using this. Note that while there's no constraint on the parse monad here,
297-- one should usually be applying decode and encode to the same 'Encoder'
311-- one should usually be applying decode and encode to the same 'Encoder'
298encode :: Encoder Identity parse decoded encoded -> decoded -> encoded
312encode :: Encoder Identity parse decoded encoded -> decoded -> encoded
299−encode (Encoder (Identity impl)) x = _encoderImpl_encode impl x
313+encode (Encoder (Identity impl)) = _encoderImpl_encode impl
300
314
301-- | This is a primitive used to build encoders which can't fail to check. It should not be used unless one is
315-- | This is a primitive used to build encoders which can't fail to check. It should not be used unless one is
302-- reasonably certain that the law given for 'EncoderImpl' above holds.
316-- reasonably certain that the law given for 'EncoderImpl' above holds.
@@ -541,11 +555,11 @@ pathComponentEncoder f = Encoder $ do
541 unEncoder (pathComponentEncoderImpl (enum1Encoder (extractPathSegment . f)) f')
555 unEncoder (pathComponentEncoderImpl (enum1Encoder (extractPathSegment . f)) f')
542
556
543pathComponentEncoderImpl :: forall check parse p. (Monad check, Monad parse)
557pathComponentEncoderImpl :: forall check parse p. (Monad check, Monad parse)
544− => (Encoder check parse (Some p) (Maybe Text))
558+ => Encoder check parse (Some p) (Maybe Text)
545 -> (forall a. p a -> Encoder Identity parse a PageName)
559 -> (forall a. p a -> Encoder Identity parse a PageName)
546 -> Encoder check parse (R p) PageName
560 -> Encoder check parse (R p) PageName
547−pathComponentEncoderImpl this rest =
561+pathComponentEncoderImpl =
548− chainEncoder (lensEncoder (\(_, b) a -> (a, b)) Prelude.fst consEncoder) this rest
562+ chainEncoder (lensEncoder (\(_, b) a -> (a, b)) Prelude.fst consEncoder)
549
563
550--NOTE: Naming convention in this module is to always talk about things in the *encoding* direction, never in the *decoding* direction
564--NOTE: Naming convention in this module is to always talk about things in the *encoding* direction, never in the *decoding* direction
551
565
@@ -801,7 +815,7 @@ rPrism
801 :: forall f f'
815 :: forall f f'
802 . (forall a. Prism' (f a) (f' a))
816 . (forall a. Prism' (f a) (f' a))
803 -> Prism' (R f) (R f')
817 -> Prism' (R f) (R f')
804−rPrism p = dSumPrism p
818+rPrism = dSumPrism
805
819
806dSumPrism'
820dSumPrism'
807 :: forall f g a
821 :: forall f g a
@@ -813,7 +827,7 @@ dSumGEqPrism
813 :: GEq f
827 :: GEq f
814 => f a
828 => f a
815 -> Prism' (DSum f g) (g a)
829 -> Prism' (DSum f g) (g a)
816−dSumGEqPrism variant = dSumPrism' $ prism' (\Refl -> variant) (\x -> geq variant x)
830+dSumGEqPrism variant = dSumPrism' $ prism' (\Refl -> variant) (geq variant)
817
831
818-- | Given a 'tag :: f a', make a prism for 'R f'. This generalizes the usual
832-- | Given a 'tag :: f a', make a prism for 'R f'. This generalizes the usual
819-- prisms for a sum type (the ones that 'mkPrisms' would make), just as 'R'
833-- prisms for a sum type (the ones that 'mkPrisms' would make), just as 'R'
@@ -980,9 +994,9 @@ obeliskRouteSegment r appRouteSegment = case r of
980-- be combined with other such segment encoders before 'pathComponentEncoder' turns it into a proper 'Encoder'.
994-- be combined with other such segment encoders before 'pathComponentEncoder' turns it into a proper 'Encoder'.
981resourceRouteSegment :: (MonadError Text check, MonadError Text parse) => ResourceRoute a -> SegmentResult check parse a
995resourceRouteSegment :: (MonadError Text check, MonadError Text parse) => ResourceRoute a -> SegmentResult check parse a
982resourceRouteSegment = \case
996resourceRouteSegment = \case
983− ResourceRoute_Static -> PathSegment "static" $ pathOnlyEncoderIgnoringQuery
997+ ResourceRoute_Static -> PathSegment "static" pathOnlyEncoderIgnoringQuery
984− ResourceRoute_Ghcjs -> PathSegment "ghcjs" $ pathOnlyEncoder
998+ ResourceRoute_Ghcjs -> PathSegment "ghcjs" pathOnlyEncoder
985− ResourceRoute_JSaddleWarp -> PathSegment "jsaddle" $ jsaddleWarpRouteEncoder
999+ ResourceRoute_JSaddleWarp -> PathSegment "jsaddle" jsaddleWarpRouteEncoder
986 ResourceRoute_Version -> PathSegment "version" $ unitEncoder mempty
1000 ResourceRoute_Version -> PathSegment "version" $ unitEncoder mempty
987
1001
988data JSaddleWarpRoute :: * -> * where
1002data JSaddleWarpRoute :: * -> * where
@@ -994,7 +1008,7 @@ jsaddleWarpRouteEncoder :: (MonadError Text check, MonadError Text parse) => Enc
994jsaddleWarpRouteEncoder = pathComponentEncoder $ \case
1008jsaddleWarpRouteEncoder = pathComponentEncoder $ \case
995 JSaddleWarpRoute_JavaScript -> PathSegment "jsaddle.js" $ unitEncoder mempty
1009 JSaddleWarpRoute_JavaScript -> PathSegment "jsaddle.js" $ unitEncoder mempty
996 JSaddleWarpRoute_WebSocket -> PathEnd $ unitEncoder mempty
1010 JSaddleWarpRoute_WebSocket -> PathEnd $ unitEncoder mempty
997− JSaddleWarpRoute_Sync -> PathSegment "sync" $ pathOnlyEncoder
1011+ JSaddleWarpRoute_Sync -> PathSegment "sync" pathOnlyEncoder
998
1012
999instance GShow appRoute => GShow (ObeliskRoute appRoute) where
1013instance GShow appRoute => GShow (ObeliskRoute appRoute) where
1000 gshowsPrec prec = \case
1014 gshowsPrec prec = \case
@@ -1025,8 +1039,8 @@ someSumEncoder = Encoder $ pure $ EncoderImpl
1025
1039
1026data Void1 :: * -> * where {}
1040data Void1 :: * -> * where {}
1027
1041
1028−instance Universe (Some Void1) where
1042+instance UniverseSome Void1 where
1029− universe = []
1043+ universeSome = []
1030
1044
1031void1Encoder :: (Applicative check, MonadError Text parse) => Encoder check parse (Some Void1) a
1045void1Encoder :: (Applicative check, MonadError Text parse) => Encoder check parse (Some Void1) a
1032void1Encoder = Encoder $ pure $ EncoderImpl
1046void1Encoder = Encoder $ pure $ EncoderImpl
@@ -1070,7 +1084,7 @@ readShowEncoder :: (MonadError Text parse, Read a, Show a, Applicative check) =>
1070readShowEncoder = singlePathSegmentEncoder . unsafeTshowEncoder
1084readShowEncoder = singlePathSegmentEncoder . unsafeTshowEncoder
1071
1085
1072integralEncoder :: (MonadError Text parse, Applicative check, Integral a) => Encoder check parse a Integer
1086integralEncoder :: (MonadError Text parse, Applicative check, Integral a) => Encoder check parse a Integer
1073−integralEncoder = reviewEncoder (Numeric.Lens.integral)
1087+integralEncoder = reviewEncoder Numeric.Lens.integral
1074
1088
1075pathSegmentEncoder :: (MonadError Text parse, Applicative check, Cons as as a a) =>
1089pathSegmentEncoder :: (MonadError Text parse, Applicative check, Cons as as a a) =>
1076 Encoder check parse (a, (as, b)) (as, b)
1090 Encoder check parse (a, (as, b)) (as, b)
@@ -1145,7 +1159,7 @@ pathFieldEncoder fieldEncoder = unsafeEncoder $ do
1145 fieldEncoderPure f = toEncoder (DMap.findWithDefault (error "bad") f fieldEncoderPureMap)
1159 fieldEncoderPure f = toEncoder (DMap.findWithDefault (error "bad") f fieldEncoderPureMap)
1146 pure $ EncoderImpl
1160 pure $ EncoderImpl
1147 { _encoderImpl_encode = \(x, rest) -> execWriter $ do
1161 { _encoderImpl_encode = \(x, rest) -> execWriter $ do
1148− _ <- traverseWithField (\f x_i -> tell (pure $ encode (fieldEncoderPure f) x_i) *> pure x_i) x
1162+ _ <- traverseWithField (\f x_i -> tell (pure $ encode (fieldEncoderPure f) x_i) $> x_i) x
1149 tell rest
1163 tell rest
1150 , _encoderImpl_decode = State.runStateT $ tabulateFieldsA $ \f -> State.get >>= \case
1164 , _encoderImpl_decode = State.runStateT $ tabulateFieldsA $ \f -> State.get >>= \case
1151 [] -> throwError $ T.pack "not enough path components"
1165 [] -> throwError $ T.pack "not enough path components"
lib/route/src/Obelisk/Route/Frontend.hs+41−28
@@ -1,24 +1,24 @@
1−{-# LANGUAGE ApplicativeDo #-}
2{-# LANGUAGE CPP #-}
1{-# LANGUAGE CPP #-}
3−{-# LANGUAGE RecursiveDo #-}
2+{-# LANGUAGE ApplicativeDo #-}
4−{-# LANGUAGE StandaloneDeriving #-}
5{-# LANGUAGE ConstraintKinds #-}
3{-# LANGUAGE ConstraintKinds #-}
4+{-# LANGUAGE DataKinds #-}
6{-# LANGUAGE DefaultSignatures #-}
5{-# LANGUAGE DefaultSignatures #-}
7{-# LANGUAGE FlexibleContexts #-}
6{-# LANGUAGE FlexibleContexts #-}
8{-# LANGUAGE FlexibleInstances #-}
7{-# LANGUAGE FlexibleInstances #-}
8+{-# LANGUAGE FunctionalDependencies #-}
9{-# LANGUAGE GADTs #-}
9{-# LANGUAGE GADTs #-}
10+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
10{-# LANGUAGE LambdaCase #-}
11{-# LANGUAGE LambdaCase #-}
11{-# LANGUAGE OverloadedStrings #-}
12{-# LANGUAGE OverloadedStrings #-}
12{-# LANGUAGE PatternSynonyms #-}
13{-# LANGUAGE PatternSynonyms #-}
13{-# LANGUAGE RankNTypes #-}
14{-# LANGUAGE RankNTypes #-}
15+{-# LANGUAGE RecursiveDo #-}
14{-# LANGUAGE ScopedTypeVariables #-}
16{-# LANGUAGE ScopedTypeVariables #-}
17+{-# LANGUAGE StandaloneDeriving #-}
15{-# LANGUAGE TypeFamilies #-}
18{-# LANGUAGE TypeFamilies #-}
16{-# LANGUAGE TypeOperators #-}
19{-# LANGUAGE TypeOperators #-}
17−{-# LANGUAGE ViewPatterns #-}
18−{-# LANGUAGE GeneralizedNewtypeDeriving #-}
19{-# LANGUAGE UndecidableInstances #-}
20{-# LANGUAGE UndecidableInstances #-}
20−{-# LANGUAGE DataKinds #-}
21+{-# LANGUAGE ViewPatterns #-}
21−{-# LANGUAGE FunctionalDependencies #-}
22
22
23module Obelisk.Route.Frontend
23module Obelisk.Route.Frontend
24 ( module Obelisk.Route
24 ( module Obelisk.Route
@@ -57,49 +57,42 @@ module Obelisk.Route.Frontend
57
57
58import Prelude hiding ((.), id)
58import Prelude hiding ((.), id)
59
59
60−import Obelisk.Route
61−
62import Control.Category (Category (..), (.))
60import Control.Category (Category (..), (.))
63import Control.Category.Cartesian ((&&&))
61import Control.Category.Cartesian ((&&&))
64import Control.Lens hiding (Bifunctor, bimap, universe, element)
62import Control.Lens hiding (Bifunctor, bimap, universe, element)
65import Control.Monad ((<=<))
63import Control.Monad ((<=<))
66import Control.Monad.Fix
64import Control.Monad.Fix
65+import Control.Monad.Morph
67import Control.Monad.Primitive
66import Control.Monad.Primitive
68import Control.Monad.Reader
67import Control.Monad.Reader
69import Control.Monad.Ref
68import Control.Monad.Ref
70import Control.Monad.Trans.Control
69import Control.Monad.Trans.Control
71import Data.Coerce
70import Data.Coerce
72import Data.Dependent.Sum (DSum (..))
71import Data.Dependent.Sum (DSum (..))
72+import Data.Functor.Compose
73+import Data.Functor.Misc
73import Data.GADT.Compare
74import Data.GADT.Compare
75+import qualified Data.List as L
74import Data.Map (Map)
76import Data.Map (Map)
77+import Data.Maybe (fromMaybe)
75import Data.Monoid
78import Data.Monoid
76import Data.Proxy
79import Data.Proxy
77import Data.Text (Text)
80import Data.Text (Text)
78import qualified Data.Text as T
81import qualified Data.Text as T
79−import Data.Functor.Compose
80−import Data.Functor.Misc
81−import Reflex.Class
82−import Reflex.Host.Class
83−import Reflex.PostBuild.Class
84−import Reflex.TriggerEvent.Class
85−import Reflex.PerformEvent.Class
86−import Reflex.EventWriter.Class
87−import Reflex.EventWriter.Base
88−import Reflex.Dynamic
89−import Reflex.Dom.Builder.Class
90import Data.Type.Coercion
82import Data.Type.Coercion
91−import Language.Javascript.JSaddle --TODO: Get rid of this - other platforms can also be routed
92−import Reflex.Dom.Core
93import qualified GHCJS.DOM as DOM
83import qualified GHCJS.DOM as DOM
94import qualified GHCJS.DOM.Types as DOM
84import qualified GHCJS.DOM.Types as DOM
95import qualified GHCJS.DOM.Window as Window
85import qualified GHCJS.DOM.Window as Window
86+import Language.Javascript.JSaddle (MonadJSM, jsNull, liftJSM) --TODO: Get rid of this - other platforms can also be routed
96import Network.URI
87import Network.URI
97−import Data.Maybe (fromMaybe)
88+import Reflex.Class
98−import qualified Data.List as L
89+import Reflex.Dom.Builder.Class
99−
90+import Reflex.Dom.Core
91+import Reflex.Host.Class
100import Unsafe.Coerce
92import Unsafe.Coerce
101
93
102import Obelisk.Configs
94import Obelisk.Configs
95+import Obelisk.Route
103
96
104infixr 5 :~
97infixr 5 :~
105pattern (:~) :: Reflex t => f a -> Dynamic t a -> DSum f (Compose (Dynamic t) Identity)
98pattern (:~) :: Reflex t => f a -> Dynamic t a -> DSum f (Compose (Dynamic t) Identity)
@@ -116,7 +109,23 @@ instance Monad m => Routed t r (RoutedT t r m) where
116instance (Monad m, Routed t r m) => Routed t r (ReaderT r' m)
109instance (Monad m, Routed t r m) => Routed t r (ReaderT r' m)
117
110
118newtype RoutedT t r m a = RoutedT { unRoutedT :: ReaderT (Dynamic t r) m a }
111newtype RoutedT t r m a = RoutedT { unRoutedT :: ReaderT (Dynamic t r) m a }
119− deriving (Functor, Applicative, Monad, MonadFix, MonadTrans, NotReady t, MonadHold t, MonadSample t, PostBuild t, TriggerEvent t, MonadIO, MonadReflexCreateTrigger t, HasDocument, DomRenderHook t)
112+ deriving
113+ ( Functor
114+ , Applicative
115+ , Monad
116+ , MonadFix
117+ , MonadTrans
118+ , MFunctor
119+ , NotReady t
120+ , MonadHold t
121+ , MonadSample t
122+ , PostBuild t
123+ , TriggerEvent t
124+ , MonadIO
125+ , MonadReflexCreateTrigger t
126+ , HasDocument
127+ , DomRenderHook t
128+ )
120
129
121instance MonadReader r' m => MonadReader r' (RoutedT t r m) where
130instance MonadReader r' m => MonadReader r' (RoutedT t r m) where
122 ask = lift ask
131 ask = lift ask
@@ -192,6 +201,10 @@ instance (Monad m, RouteToUrl r m) => RouteToUrl r (EventWriterT t w m)
192
201
193instance (Monad m, SetRoute t r m) => SetRoute t r (EventWriterT t w m)
202instance (Monad m, SetRoute t r m) => SetRoute t r (EventWriterT t w m)
194
203
204+instance (Monad m, RouteToUrl r m) => RouteToUrl r (DynamicWriterT t w m)
205+
206+instance (Monad m, SetRoute t r m) => SetRoute t r (DynamicWriterT t w m)
207+
195runRoutedT :: RoutedT t r m a -> Dynamic t r -> m a
208runRoutedT :: RoutedT t r m a -> Dynamic t r -> m a
196runRoutedT = runReaderT . unRoutedT
209runRoutedT = runReaderT . unRoutedT
197
210
@@ -256,7 +269,7 @@ dynamicIdentityCoercion = unsafeCoerce (Coercion :: Coercion (Identity ()) ()) -
256factorRouted :: (Reflex t, MonadFix m, MonadHold t m, GEq f) => RoutedT t (DSum f (Dynamic t)) m a -> RoutedT t (DSum f Identity) m a
269factorRouted :: (Reflex t, MonadFix m, MonadHold t m, GEq f) => RoutedT t (DSum f (Dynamic t)) m a -> RoutedT t (DSum f Identity) m a
257factorRouted r = RoutedT $ ReaderT $ \d -> do
270factorRouted r = RoutedT $ ReaderT $ \d -> do
258 d' <- factorDyn d
271 d' <- factorDyn d
259− runRoutedT r $ (coerceWith (dynamicCoercion $ dsumValueCoercion dynamicIdentityCoercion) d')
272+ runRoutedT r $ coerceWith (dynamicCoercion $ dsumValueCoercion dynamicIdentityCoercion) d'
260
273
261maybeRouted :: (Reflex t, MonadFix m, MonadHold t m) => RoutedT t (Maybe (Dynamic t a)) m b -> RoutedT t (Maybe a) m b
274maybeRouted :: (Reflex t, MonadFix m, MonadHold t m) => RoutedT t (Maybe (Dynamic t a)) m b -> RoutedT t (Maybe a) m b
262maybeRouted r = RoutedT $ ReaderT $ \d -> do
275maybeRouted r = RoutedT $ ReaderT $ \d -> do
@@ -464,7 +477,7 @@ runRouteViewT
464 , MonadJSM (Performable m)
477 , MonadJSM (Performable m)
465 , MonadFix m
478 , MonadFix m
466 )
479 )
467− => (Encoder Identity Identity r PageName)
480+ => Encoder Identity Identity r PageName
468 --TODO: Get rid of the switchover and useHash arguments
481 --TODO: Get rid of the switchover and useHash arguments
469 -- useHash can probably be baked into the encoder
482 -- useHash can probably be baked into the encoder
470 -> Event t () -- ^ Switchover event, nothing is done until this event fires. Used to prevent incorrect DOM expectations at hydration switchover time
483 -> Event t () -- ^ Switchover event, nothing is done until this event fires. Used to prevent incorrect DOM expectations at hydration switchover time
lib/run/obelisk-run.cabal+2−2
@@ -33,7 +33,7 @@ library
33 , process
33 , process
34 , ref-tf
34 , ref-tf
35 , reflex
35 , reflex
36− , reflex-dom
36+ , reflex-dom-core
37 , snap-core
37 , snap-core
38 , streaming-commons
38 , streaming-commons
39 , text
39 , text
@@ -47,7 +47,7 @@ library
47 , websockets
47 , websockets
48 exposed-modules:
48 exposed-modules:
49 Obelisk.Run
49 Obelisk.Run
50− ghc-options: -Wall -fwarn-redundant-constraints
50+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
51 if os(linux)
51 if os(linux)
52 cpp-options: -DIPROUTE_SUPPORTED
52 cpp-options: -DIPROUTE_SUPPORTED
53 build-depends: which
53 build-depends: which
lib/run/src/Obelisk/Run.hs+3−3
@@ -144,9 +144,9 @@ runWidget conf configs frontend validFullEncoder = do
144
144
145 cert <- X509.newX509 >>= X509Request.makeX509FromReq certRequest
145 cert <- X509.newX509 >>= X509Request.makeX509FromReq certRequest
146 _ <- X509.setPublicKey cert privateKey
146 _ <- X509.setPublicKey cert privateKey
147− now <- getCurrentTime
147+ timenow <- getCurrentTime
148− _ <- X509.setNotBefore cert $ addUTCTime (-1) now
148+ _ <- X509.setNotBefore cert $ addUTCTime (-1) timenow
149− _ <- X509.setNotAfter cert $ addUTCTime (365 * 24 * 60 * 60) now
149+ _ <- X509.setNotAfter cert $ addUTCTime (365 * 24 * 60 * 60) timenow
150 _ <- X509.signX509 cert privateKey Nothing
150 _ <- X509.signX509 cert privateKey Nothing
151
151
152 certByteString <- BSUTF8.fromString <$> PEM.writeX509 cert
152 certByteString <- BSUTF8.fromString <$> PEM.writeX509 cert
lib/selftest/src/Obelisk/SelfTest.hs+23−1
@@ -19,6 +19,7 @@ import Data.Bool (bool)
19import qualified Data.ByteString.Lazy as LBS
19import qualified Data.ByteString.Lazy as LBS
20import Data.Foldable (for_)
20import Data.Foldable (for_)
21import Data.Function (fix)
21import Data.Function (fix)
22+import Data.List (isInfixOf)
22import qualified Data.Map as Map
23import qualified Data.Map as Map
23import Data.Semigroup ((<>))
24import Data.Semigroup ((<>))
24import qualified Data.Set as Set
25import qualified Data.Set as Set
@@ -205,6 +206,22 @@ main' isVerbose httpManager obeliskRepoReadOnly = withInitCache $ \initCache ->
205 it "works in root directory" $ inTmpObInit $ \_ -> testObRunInDir' Nothing httpManager
206 it "works in root directory" $ inTmpObInit $ \_ -> testObRunInDir' Nothing httpManager
206 it "works in sub directory" $ inTmpObInit $ \_ -> testObRunInDir' (Just "frontend") httpManager
207 it "works in sub directory" $ inTmpObInit $ \_ -> testObRunInDir' (Just "frontend") httpManager
207
208
209+ describe "ob repl" $ do
210+ it "accepts stdin commands" $ inTmpObInit $ \_ -> do
211+ setStdin "print 3\n:q"
212+ output <- runOb ["repl"]
213+ liftIO $ assertBool "" $
214+ [ "*Obelisk.Run Obelisk.Run Frontend Backend> 3"
215+ , "*Obelisk.Run Obelisk.Run Frontend Backend> Leaving GHCi."
216+ ] `isInfixOf` T.lines (T.strip output)
217+ it "works with custom Prelude" $ inTmpObInit $ \_ -> do
218+ writefile "common/src/Prelude.hs"
219+ "{-# LANGUAGE PackageImports #-} module Prelude (module X) where import \"base\" Prelude as X"
220+ setStdin ":q"
221+ output <- runOb ["repl"]
222+ liftIO $ assertBool "" $
223+ "*Obelisk.Run Obelisk.Run Frontend Backend> Leaving GHCi." `T.isInfixOf` output
224+
208 describe "obelisk project" $ parallel $ do
225 describe "obelisk project" $ parallel $ do
209 it "can build obelisk command" $ inTmpObInit $ \_ -> nixBuild ["-A", "command" , toTextIgnore obeliskRepoReadOnly]
226 it "can build obelisk command" $ inTmpObInit $ \_ -> nixBuild ["-A", "command" , toTextIgnore obeliskRepoReadOnly]
210 it "can build obelisk skeleton" $ inTmpObInit $ \_ -> nixBuild ["-A", "skeleton", toTextIgnore obeliskRepoReadOnly]
227 it "can build obelisk skeleton" $ inTmpObInit $ \_ -> nixBuild ["-A", "skeleton", toTextIgnore obeliskRepoReadOnly]
@@ -243,7 +260,7 @@ main' isVerbose httpManager obeliskRepoReadOnly = withInitCache $ \initCache ->
243 uu <- update
260 uu <- update
244 assertRevEQ u uu
261 assertRevEQ u uu
245
262
246− it "can run 'ob doc'" $ inTmpObInit $ \_ -> runOb ["doc", "reflex"]
263+ it "can run 'ob doc'" $ inTmpObInit $ \_ -> runOb_ ["doc", "reflex"]
247
264
248 describe "ob thunk pack/unpack" $ parallel $ do
265 describe "ob thunk pack/unpack" $ parallel $ do
249 it "has thunk pack and unpack inverses" $ inTmpObInitWithImplCopy $ \_ -> do
266 it "has thunk pack and unpack inverses" $ inTmpObInitWithImplCopy $ \_ -> do
@@ -306,6 +323,11 @@ main' isVerbose httpManager obeliskRepoReadOnly = withInitCache $ \initCache ->
306 void $ errExit False $ runOb ["thunk", "update", toTextIgnore dir, "--branch", "dumble-palooza"]
323 void $ errExit False $ runOb ["thunk", "update", toTextIgnore dir, "--branch", "dumble-palooza"]
307 checkDir dir >>= liftIO . assertEqual "" startingContents
324 checkDir dir >>= liftIO . assertEqual "" startingContents
308
325
326+ describe "ob shell" $ parallel $ do
327+ it "works with --" $ inTmpObInit $ \_ -> do
328+ output <- runOb ["shell", "--", "ghc-pkg", "list"]
329+ liftIO $ assertBool "Unexpected output from ob shell" $ ("Cabal-" `T.isInfixOf` output) && ("ghc-" `T.isInfixOf` output)
330+
309 describe "ob hoogle" $ {- NOT parallel -} do
331 describe "ob hoogle" $ {- NOT parallel -} do
310 it "starts a hoogle server on the given port" $ inTmpObInit $ \_ -> do
332 it "starts a hoogle server on the given port" $ inTmpObInit $ \_ -> do
311 [p0] <- liftIO $ getFreePorts 1
333 [p0] <- liftIO $ getFreePorts 1
lib/snap-extras/obelisk-snap-extras.cabal+1−2
@@ -12,10 +12,9 @@ library
12 , base
12 , base
13 , bytestring
13 , bytestring
14 , snap-core
14 , snap-core
15− , unix
16 , directory
15 , directory
17 , filepath
16 , filepath
18 , text
17 , text
19 exposed-modules:
18 exposed-modules:
20 Obelisk.Snap.Extras
19 Obelisk.Snap.Extras
21− ghc-options: -Wall
20+ ghc-options: -Wall -Werror -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O
lib/snap-extras/src/Obelisk/Snap/Extras.hs+1−1
@@ -17,7 +17,7 @@ import System.Directory
17-- | Set response header for "permanent" caching
17-- | Set response header for "permanent" caching
18cachePermanently :: MonadSnap m => m ()
18cachePermanently :: MonadSnap m => m ()
19cachePermanently = do
19cachePermanently = do
20− modifyResponse $ setHeader "Cache-Control" "public, max-age=315360000"
20+ modifyResponse $ setHeader "Cache-Control" "public, max-age=315360000, immutable"
21 modifyResponse $ setHeader "Expires" "Tue, 01 Feb 2050 00:00:00 GMT" --TODO: This should be set to "approximately one year from the time the response is sent"
21 modifyResponse $ setHeader "Expires" "Tue, 01 Feb 2050 00:00:00 GMT" --TODO: This should be set to "approximately one year from the time the response is sent"
22
22
23-- | Set response header to not cache
23-- | Set response header to not cache
scripts/ghcid-this-libdeleted−4
@@ -1,4 +0,0 @@
1−#!/usr/bin/env bash
2−set -euo pipefail
3−
4−nix-shell -E "with (import ../.. {}); reflex-platform.workOn haskellPackageSets.ghc haskellPackageSets.ghc.obelisk-$(basename $PWD)" --run "ghcid -c 'cabal new-repl'"
skeleton/.gitignore+12−6
@@ -1,9 +1,15 @@
1−dist-newstyle
2−result
3−result-*
4−result-android
5−result-ios
6−result-exe
7.attr-cache
1.attr-cache
2+.cabal-sandbox
3+*.hi
4+*.o
5+cabal.project.local
6+cabal.sandbox.config
7+ctags
8+dist-newstyle/
9+dist/
8ghcid-output.txt
10ghcid-output.txt
9profile/
11profile/
12+result
13+result-*
14+tags
15+TAGS
skeleton/backend/backend.cabal+2−1
@@ -14,11 +14,12 @@ library
14 , obelisk-route
14 , obelisk-route
15 exposed-modules:
15 exposed-modules:
16 Backend
16 Backend
17− ghc-options: -Wall
17+ ghc-options: -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O -fno-show-valid-hole-fits
18
18
19executable backend
19executable backend
20 main-is: main.hs
20 main-is: main.hs
21 hs-source-dirs: src-bin
21 hs-source-dirs: src-bin
22+ ghc-options: -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O -threaded -fno-show-valid-hole-fits
22 if impl(ghcjs)
23 if impl(ghcjs)
23 buildable: False
24 buildable: False
24 build-depends: base
25 build-depends: base
skeleton/cabal.project+1
@@ -1,2 +1,3 @@
1optional-packages:
1optional-packages:
2 *
2 *
3+write-ghc-environment-files: never
skeleton/common/common.cabal+1
@@ -12,3 +12,4 @@ library
12 exposed-modules:
12 exposed-modules:
13 Common.Api
13 Common.Api
14 Common.Route
14 Common.Route
15+ ghc-options: -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O -fno-show-valid-hole-fits
skeleton/default.nix+10−3
@@ -1,10 +1,17 @@
1−{ obelisk ? import ./.obelisk/impl {
2− system = builtins.currentSystem;
1+{ system ? builtins.currentSystem
2+, obelisk ? import ./.obelisk/impl {
3+ inherit system;
3− iosSdkVersion = "10.2";
4+ iosSdkVersion = "13.2";
5+
4 # You must accept the Android Software Development Kit License Agreement at
6 # You must accept the Android Software Development Kit License Agreement at
5 # https://developer.android.com/studio/terms in order to build Android apps.
7 # https://developer.android.com/studio/terms in order to build Android apps.
6 # Uncomment and set this to `true` to indicate your acceptance:
8 # Uncomment and set this to `true` to indicate your acceptance:
7 # config.android_sdk.accept_license = false;
9 # config.android_sdk.accept_license = false;
10+
11+ # In order to use Let's Encrypt for HTTPS deployments you must accept
12+ # their terms of service at https://letsencrypt.org/repository/.
13+ # Uncomment and set this to `true` to indicate your acceptance:
14+ # terms.security.acme.acceptTerms = false;
8 }
15 }
9}:
16}:
10with obelisk;
17with obelisk;
skeleton/frontend/frontend.cabal+6−4
@@ -16,7 +16,7 @@ library
16 , text
16 , text
17 exposed-modules:
17 exposed-modules:
18 Frontend
18 Frontend
19− ghc-options: -Wall
19+ ghc-options: -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -O -fno-show-valid-hole-fits
20
20
21executable frontend
21executable frontend
22 main-is: main.hs
22 main-is: main.hs
@@ -28,7 +28,9 @@ executable frontend
28 , reflex-dom
28 , reflex-dom
29 , obelisk-generated-static
29 , obelisk-generated-static
30 , frontend
30 , frontend
31− --TODO: Make these ghc-options optional
31+ ghc-options: -threaded -O -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -fno-show-valid-hole-fits
32− ghc-options: -threaded
32+ if impl(ghcjs)
33+ ghc-options: -dedupe
34+ cpp-options: -DGHCJS_BROWSER
33 if os(darwin)
35 if os(darwin)
34− ghc-options: -dynamic
36+ ghc-options: -dynamic
skeleton/shell.nixdeleted−1
@@ -1 +0,0 @@
1−(import ./. {}).shells.ghc