6eca276...master · obelisk

.github/pull_request_template.md+2

since splitsnapshots

unifiedsplit

@@ -3,6 +3,8 @@

3I have:

4

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+13−6

@@ -82,31 +82,38 @@ The readme is the first place a lot of people look for information about the rep

82

83## Development Environment

84

85−You may launch `ghcid` for the corresponding project as follows. For example to launch ghcid for `lib/backend` project:

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−nix-shell -A obeliskEnvs.obelisk-backend --run "cd lib/backend && ghcid"

88+cd skeleton

89+ob run

89```

90```

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+

91−Or to launch ghcid for `lib/command` project:

94+For other libraries like `obelisk-command` you can use `ghcid`. To launch `ghcid` for `lib/command` you can run

92

95

93```bash

96```bash

94nix-shell -A obeliskEnvs.obelisk-command --run "cd lib/command && ghcid"

97nix-shell -A obeliskEnvs.obelisk-command --run "cd lib/command && ghcid"

95```

98```

96

99

100+### Building `ob` for testing

101+

97−To re-install `ob` from source do

102+To re-install `ob` from source globally you can do

103+

98```bash

104```bash

99nix-env -f /path/to/obelisk -iA command

105nix-env -f /path/to/obelisk -iA command

100```

106```

101

107

102−You can also open a shell with the local version of `ob` available on your `PATH`:

108+You can also open a shell with the local version of `ob` available on your `$PATH`:

103

109

104```bash

110```bash

105nix run -f /path/to/obelisk command

111nix run -f /path/to/obelisk command

106```

112```

107

113

114+### Hacking on Obelisk from within an Obelisk project

108

115

109−Note that `ob` will defer to the version found in your project's `.obelisk/impl` directory. To update that version specifically:

116+`ob` will defer to the version found in your project's `.obelisk/impl` directory. To work on that version specifically:

110

117

111```bash

118```bash

112ob thunk unpack ./.obelisk/impl

119ob thunk unpack ./.obelisk/impl

ChangeLog.md+21−3

@@ -2,8 +2,26 @@

2

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

4

5−## Unreleased

5+## v0.9.1.0

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`.

8* ([#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`.

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`.

9* ([#735](https://github.com/obsidiansystems/obelisk/pull/735)) Fix regression causing custom `Prelude`s to break `ob run`/`ob watch`/`ob repl`.

27* ([#735](https://github.com/obsidiansystems/obelisk/pull/735)) Fix regression causing custom `Prelude`s to break `ob run`/`ob watch`/`ob repl`.

@@ -23,7 +41,7 @@ This project's release branch is `master`. This log is written from the perspect

23* ([#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.

24* ([#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`.

25* ([#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.

26−* ([#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`.

27* ([#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`.

28* ([#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.

29* ([#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.

@@ -74,7 +92,7 @@ This project's release branch is `master`. This log is written from the perspect

74* 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))

75* 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))

76* 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))

77−* 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))

78

96

79## v0.3.0.0 - 2019-12-20

97## v0.3.0.0 - 2019-12-20

80

98

FAQ.md+59−2

@@ -1,13 +1,70 @@

1# Frequently Asked Questions

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)

31. [How do I fix invalid entitlements?](#how-do-i-fix-invalid-entitlements)

71. [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

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+

64+

7### How do I fix invalid entitlements?

65### How do I fix invalid entitlements?

8

66

9−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:

10−When this happens you'll see an error something like this:

11

68

12```

69```

132018-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)

README.md+58−135

@@ -1,42 +1,40 @@

1# Obelisk

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://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

6<p align="center"><img src="docs/obelisk-logo-640.png" width="50%" alt="Obelisk Logo"></p>

7

8−Obelisk is an opinionated, batteries-included framework for building production-ready web and mobile applications in [Haskell](https://www.haskell.org/). It'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+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.

9

10−- [Overview](#installing-obelisk)

10+- [Overview](#overview)

11− - [Why would I use it?](#why-would-i-use-it)

12 - [Who should consider using it?](#who-should-consider-using-it)

11 - [Who should consider using it?](#who-should-consider-using-it)

13- [Installing Obelisk](#installing-obelisk)

12- [Installing Obelisk](#installing-obelisk)

14- [Developing an Obelisk project](#developing-an-obelisk-project)

13- [Developing an Obelisk project](#developing-an-obelisk-project)

15− - [Adding Packages](#adding-packages)

16− - [Adding Package Overrides](#adding-package-overrides)

17− - [Running over HTTPS](#running-over-https)

18 - [IDE Support](#ide-support)

14 - [IDE Support](#ide-support)

19− - [Terminal-based feedback](#terminal-based-feedback)

20- [Deploying](#deploying)

15- [Deploying](#deploying)

21− - [Locally](#locally)

22 - [Default EC2 Deployment](#default-ec2-deployment)

16 - [Default EC2 Deployment](#default-ec2-deployment)

23 - [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)

17 - [Custom Non-EC2 Deployment](#custom-non-ec2-deployment)

24 - [VirtualBox Deployment](#virtualbox-deployment)

18 - [VirtualBox Deployment](#virtualbox-deployment)

19+ - [Locally](#locally)

25 - [From macOS](#from-macos)

20 - [From macOS](#from-macos)

26 - [Deploying an updated version](#deploying-an-updated-version)

21 - [Deploying an updated version](#deploying-an-updated-version)

27- [Mobile](#mobile)

22- [Mobile](#mobile)

28 - [iOS](#ios)

23 - [iOS](#ios)

29 - [Android](#android)

24 - [Android](#android)

25+- [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)

26+- [Contributing](#contributing)

30

27

31## Overview

28## Overview

32

29

33−### Why would I use it?

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.

34

31

35−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 a 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.

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.

36

33

37### Who should consider using it?

34### Who should consider using it?

38

35

39−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.

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+

40

38

41## Installing Obelisk

39## Installing Obelisk

42

40

@@ -44,31 +42,34 @@ Obelisk is targeted primarily at Haskell developers who want to build high-quali

44 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`.

451. Set up nix caches

431. Set up nix caches

46 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`:

47− ```

45+ ```nix

48 nix.binaryCaches = [ "https://nixcache.reflex-frp.org" ];

46 nix.binaryCaches = [ "https://nixcache.reflex-frp.org" ];

49 nix.binaryCachePublicKeys = [ "ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=" ];

47 nix.binaryCachePublicKeys = [ "ryantrinkle.com-1:JJiAKaRv9mWgpVAz8dwewnZe0AzzEAzPkagE9SP5NWI=" ];

50 ```

48 ```

51 and rebuild your NixOS configuration (e.g. `sudo nixos-rebuild switch`).

49 and rebuild your NixOS configuration (e.g. `sudo nixos-rebuild switch`).

52− 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)):

53− ```

51+ ```nix

54− binary-caches = https://cache.nixos.org https://nixcache.reflex-frp.org

52+ binary-caches = https://cache.nixos.org https://nixcache.reflex-frp.org

55− 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=

56− binary-caches-parallel-connections = 40

54+ binary-caches-parallel-connections = 40

57 ```

55 ```

58− * 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:

59− ```

57+ ```nix

60 sandbox = true

58 sandbox = true

61 ```

59 ```

62− * 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:

63− ```

61+ ```nix

64 sandbox = false

62 sandbox = false

65 ```

63 ```

66 then restart the nix daemon

64 then restart the nix daemon

67− ```

65+ ```bash

68 sudo launchctl stop org.nixos.nix-daemon

66 sudo launchctl stop org.nixos.nix-daemon

69 sudo launchctl start org.nixos.nix-daemon

67 sudo launchctl start org.nixos.nix-daemon

70 ```

68 ```

69+1. Install obelisk:

70+ ```bash

71−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

72+ ```

72

73

73### Accessing private repositories

74### Accessing private repositories

74

75

@@ -98,119 +99,12 @@ Firefox will not be able to properly run the development website due to [issue 4

98

99

99Every 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.

100

101

101−### Adding packages

102−

103−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.

104−

105−### Adding package overrides

106−

107−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:

108−

109−```nix

110−# ...

111−project ./. ({ pkgs, ... }: {

112−# ...

113− overrides = self: super: let

114− aesonSrc = pkgs.fetchFromGitHub {

115− owner = "obsidiansystems";

116− repo = "aeson-gadt-th";

117− rev = "ed573c2cccf54d72aa6279026752a3fecf9c1383";

118− sha256 = "08q6rnz7w9pn76jkrafig6f50yd0f77z48rk2z5iyyl2jbhcbhx3";

119− };

120− in

121− {

122− aeson = self.callCabal2nix "aeson" aesonSrc {};

123− waargonaut = self.callHackageDirect {

124− pkg = "waargonaut";

125− ver = "0.8.0.1";

126− sha256 = "1zv28np3k3hg378vqm89v802xr0g8cwk7gy3mr77xrzy5jbgpa39";

127− } {};

128− };

129−# ...

130−```

131−

132−For further information see [the Haskell section](https://nixos.org/nixpkgs/manual/#users-guide-to-the-haskell-infrastructure) of nixpkgs Contributors Guide.

133−

134−### Adding extra local packages

135−

136−If the standard packages (`frontend`, `backend`, and `common`) are not

137−enough, to add more local Haskell packages, define them with the

138−`packages` parameter. The sources of these packages will be

139−automatically reloaded by `ob run`.

140−

141−```nix

142−# ...

143−project ./. ({ pkgs, ... }: {

144−# ...

145− packages = {

146− another = ./another;

147− };

148−# ...

149−```

150−

151−### Running over HTTPS

152−

153−To run your app locally over HTTPS, update the protocol in `config/common/route` to `https`, and then use `ob run` as normal.

154−

155−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.

156−

157### IDE Support

102### IDE Support

158

103

159−#### Terminal-based feedback

160−

161Obelisk 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`.

162

105

163−#### **Experimental** `ghcide` support

164−

165−> **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.

166−

167−To try out the **experimental** [`ghcide`](https://github.com/digital-asset/ghcide) support:

168−

169− * Install a `ghcide` plugin for your editor.

170− * 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.

171− * Add `hie-bios.sh` to the root of your project:

172− ```shell

173− cat > hie-bios.sh <<'EOF'

174− #!/usr/bin/env bash

175− 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`

176− ob internal export-ghci-configuration > "$HIE_BIOS_OUTPUT"

177− EOF

178− chmod +x hie-bios.sh

179− ```

180− * **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.

181− * Add `hie.yaml` to the root of your project:

182− ```shell

183− echo 'cradle: { bios: { program: hie-bios.sh } }' > hie.yaml

184− ```

185− * Test the configuration with `ob shell ghcide`. Assuming your project compiles and works with `ghcide` otherwise, this should succeed.

186− * Start your editor in a way that it can access the appropriate `ghcide`:

187− * This can sometimes be achieved with `ob shell 'start my editor'`.

188− * 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:

189− ```shell

190− #!/usr/bin/env bash

191− source "$HOME/.bash_profile" # NOTE: This assumes that `ob` is made available on your `$PATH` in `.bash_profile`

192− ob shell "ghcide $@"

193− ```

194−

195## Deploying

106## Deploying

196

107

197−### Locally

198−

199−Build everything:

200−

201−```bash

202−nix-build -A exe --no-out-link

203−```

204−

205−Copy the result to a new directory, add configuration, and run!

206−

207−```bash

208−mkdir test-app

209−ln -s $(nix-build -A exe --no-out-link)/* test-app/

210−cp -r config test-app

211−(cd test-app && ./backend)

212−```

213−

214### Default EC2 Deployment

108### Default EC2 Deployment

215

109

216In 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)).

@@ -220,14 +114,14 @@ First create a new EC2 instance:

2201. 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))

2211. 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.

2221. 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.

223−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.

224

118

225At 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.

226

120

227Now 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`):

228Your 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.

229

123

230−```

124+```bash

231cd ~/code/myapp

125cd ~/code/myapp

232SERVER=ec2-35-183-22-197.ca-central-1.compute.amazonaws.com

126SERVER=ec2-35-183-22-197.ca-central-1.compute.amazonaws.com

233ROUTE=https://myapp.com # Publicly accessible route to your app

127ROUTE=https://myapp.com # Publicly accessible route to your app

@@ -246,7 +140,7 @@ This step will also require that you manually verify the authenticity of the hos

246

140

247Next, go to the deployment directory that you just initialized and deploy!

141Next, go to the deployment directory that you just initialized and deploy!

248

142

249−```

143+```bash

250cd ~/code/myapp-deploy

144cd ~/code/myapp-deploy

251ob deploy push

145ob deploy push

252```

146```

@@ -275,6 +169,25 @@ Here's a `module.nix` that is configured for deployment to a VirtualBox VM (runn

275

169

276The `{...}:` 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.

277

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+

278### From macOS

191### From macOS

279

192

280Deploying from macOS requires some extra setup:

193Deploying from macOS requires some extra setup:

@@ -308,7 +221,7 @@ Your account must also belong to an Apple Developer Team, if you want to access

3081. Click accept to authorize on both the computer and the iPhone.

2211. Click accept to authorize on both the computer and the iPhone.

309

222

310##### Xcode

223##### Xcode

311−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.

312

225

313These 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`

314

227

@@ -401,3 +314,13 @@ This should copy over and install the application on your device (if you see a

401##### Build a release version

314##### Build a release version

402

315

403After 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.<name>.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 ? {

2 config.android_sdk.accept_license = true;

3− iosSdkVersion = "10.2";

3+ iosSdkVersion = "13.2";

4 }

5, local-self ? import ./. self-args

6, supportedSystems ? [ builtins.currentSystem ]

default.nix+44−15

@@ -1,7 +1,10 @@

1{ system ? builtins.currentSystem

2, profiling ? false

3−, iosSdkVersion ? "10.2"

3+, iosSdkVersion ? "13.2"

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 };

dep/reflex-platform/github.json+3−3

@@ -1,8 +1,8 @@

1{

2 "owner": "reflex-frp",

3 "repo": "reflex-platform",

4− "branch": "develop",

4+ "branch": "release/0.7.0.0",

5 "private": false,

6− "rev": "c21ec7036c8351185cd2feef9ce577b6a61c4f22",

6+ "rev": "27a7851a780ff21472d85f9a02fb84635ef9027a",

7− "sha256": "0m4sdpz6qvngralpyprrbvsyi2zmfh2l3q5vhihwfp3842blvbfg"

7+ "sha256": "1m4zlw91dpjlbdchjyxhvhv3k7lilm0qa17dhhww868xxc27sann"

8}

guides/app-deploy/README.md+2−2

@@ -8,7 +8,7 @@ This document serves two purposes, the first one is to guide new users that want

8

9## a) Get Obelisk (Linux, Mac)

10

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 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.

12

13Open a terminal and run the following:

14

@@ -81,7 +81,7 @@ You should now see a NixOS machine in the dashboard:

81

82![](assets/virtualbox-dashboard-nixos.png)

83

84−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".

85

86![](assets/virtualbox-image-settings-network.png)

87

haskell-overlays/ghcide.nix+38−32

@@ -1,34 +1,40 @@

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

10

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+4

@@ -19,8 +19,12 @@ in

19 obelisk-command = haskellLib.overrideCabal (self.callCabal2nix "obelisk-command" (obeliskCleanSource ../lib/command) {}) {

20 librarySystemDepends = [

21 pkgs.jre

22+ pkgs.git

22 pkgs.nix

23 pkgs.nix

23 pkgs.nix-prefetch-git

24 pkgs.nix-prefetch-git

25+ pkgs.openssh

26+ pkgs.rsync

27+ pkgs.which

24 (haskellLib.justStaticExecutables self.ghcid)

28 (haskellLib.justStaticExecutables self.ghcid)

25 ];

29 ];

26 };

30 };

lib/asset/README.md+16−19

@@ -1,29 +1,26 @@

1−## obelisk-asset

1+# obelisk-asset

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;

20```

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 {

21 name = "encodings";

22

23− input = file;

23+ input = mkPath file;

24

25 builder = builtins.toFile "builder.sh" ''

26 source "$stdenv/setup"

@@ -46,7 +46,7 @@ gzipEncodings = file:

46 nixpkgs.stdenv.mkDerivation {

47 name = "encodings";

48

49− input = file;

49+ input = mkPath file;

50

51 builder = builtins.toFile "builder.sh" ''

52 source "$stdenv/setup"

@@ -70,7 +70,7 @@ noEncodings = file:

70 nixpkgs.stdenv.mkDerivation {

71 name = "encodings";

72

73− input = file;

73+ input = mkPath file;

74

75 builder = builtins.toFile "builder.sh" ''

76 source "$stdenv/setup"

@@ -203,7 +203,7 @@ hashFile = path:

203 nixpkgs.nix

204 ];

205 preferLocalBuild = true;

206− inherit path;

206+ path = mkPath path;

207 } ''

208 nix-hash --flat --base32 --type sha256 "$path" | tr -d '\n' >"$out"

209 '');

@@ -224,7 +224,30 @@ symlink = path: {

224 inherit path;

225};

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+3−1

@@ -33,7 +33,9 @@ library

33 Obelisk.Asset.TH

34

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/serve-snap/obelisk-asset-serve-snap.cabal+3−1

@@ -29,4 +29,6 @@ library

29 Obelisk.Asset.Serve.Snap

30

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/backend/obelisk-backend.cabal+2−2

@@ -21,10 +21,10 @@ library

21 obelisk-frontend,

22 obelisk-route,

23 obelisk-snap-extras,

24− reflex-dom,

24+ reflex-dom-core,

25 snap,

26 snap-server,

27 text,

28 universe

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

59import Obelisk.Route

60import Obelisk.Snap.Extras (doNotCache, serveFileIfExistsAs)

61−import Reflex.Dom

61+import Reflex.Dom.Core

62import Snap (MonadSnap, Snap, commandLineConfig, defaultConfig, getsRequest, httpServe, modifyResponse

63 , rqPathInfo, rqQueryString, setContentType, writeBS, writeText

64 , rqCookies, Cookie(..) , setHeader)

lib/cliapp/obelisk-cliapp.cabal+1−1

@@ -34,4 +34,4 @@ library

34 Obelisk.CliApp.TerminalString

35 Obelisk.CliApp.Theme

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/Logging.hs+2−2

@@ -160,7 +160,7 @@ failWith :: (CliThrow e m, AsUnstructuredError e) => Text -> m a

160failWith = throwError . review asUnstructuredError

161

162errorToWarning

163− :: (HasCliConfig e m, CliThrow e m, CliLog m)

163+ :: (HasCliConfig e m, CliLog m)

164 => e -> m ()

165errorToWarning e = do

166 c <- getCliConfig

@@ -177,7 +177,7 @@ withExitFailMessage msg f = f `catch` \(e :: ExitCode) -> do

177 throwM e

178

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

182 where

183 write

lib/cliapp/src/Obelisk/CliApp/Process.hs+6−7

@@ -1,7 +1,6 @@

1{-# LANGUAGE FlexibleContexts #-}

2{-# LANGUAGE LambdaCase #-}

3{-# LANGUAGE MultiParamTypeClasses #-}

4−{-# LANGUAGE MultiWayIf #-}

5{-# LANGUAGE OverloadedStrings #-}

4{-# LANGUAGE OverloadedStrings #-}

6{-# LANGUAGE ScopedTypeVariables #-}

5{-# LANGUAGE ScopedTypeVariables #-}

7{-# LANGUAGE TupleSections #-}

6{-# LANGUAGE TupleSections #-}

@@ -102,7 +101,7 @@ instance AsProcessFailure ProcessFailure where

102 asProcessFailure = id

101 asProcessFailure = id

103

102

104readProcessAndLogStderr

103readProcessAndLogStderr

105− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m, MonadMask m)

104+ :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)

106 => Severity -> ProcessSpec -> m Text

105 => Severity -> ProcessSpec -> m Text

107readProcessAndLogStderr sev process = do

106readProcessAndLogStderr sev process = do

108 (out, _err) <- withProcess process $ \_out err -> do

107 (out, _err) <- withProcess process $ \_out err -> do

@@ -110,7 +109,7 @@ readProcessAndLogStderr sev process = do

110 liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out

109 liftIO $ T.decodeUtf8With lenientDecode <$> BS.hGetContents out

111

110

112readProcessJSONAndLogStderr

111readProcessJSONAndLogStderr

113− :: (Aeson.FromJSON a, MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m, MonadMask m)

112+ :: (Aeson.FromJSON a, MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)

114 => Severity -> ProcessSpec -> m a

113 => Severity -> ProcessSpec -> m a

115readProcessJSONAndLogStderr sev process = do

114readProcessJSONAndLogStderr sev process = do

116 (out, _err) <- withProcess process $ \_out err -> do

115 (out, _err) <- withProcess process $ \_out err -> do

@@ -123,7 +122,7 @@ readProcessJSONAndLogStderr sev process = do

123 throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) 0

122 throwError $ review asProcessFailure $ ProcessFailure (Process.cmdspec $ _processSpec_createProcess process) 0

124

123

125readCreateProcessWithExitCode

124readCreateProcessWithExitCode

126− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e)

125+ :: (MonadIO m, CliLog m)

127 => ProcessSpec -> m (ExitCode, String, String)

126 => ProcessSpec -> m (ExitCode, String, String)

128readCreateProcessWithExitCode procSpec = do

127readCreateProcessWithExitCode procSpec = do

129 process <- mkCreateProcess procSpec

128 process <- mkCreateProcess procSpec

@@ -159,7 +158,7 @@ readProcessAndLogOutput (sev_out, sev_err) process = do

159-- 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

160-- `callProcessAndLogOutput (Debug, Debug)`.

159-- `callProcessAndLogOutput (Debug, Debug)`.

161callProcessAndLogOutput

160callProcessAndLogOutput

162− :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadFail m, MonadMask m)

161+ :: (MonadIO m, CliLog m, CliThrow e m, AsProcessFailure e, MonadMask m)

163 => (Severity, Severity) -> ProcessSpec -> m ()

162 => (Severity, Severity) -> ProcessSpec -> m ()

164callProcessAndLogOutput (sev_out, sev_err) process =

163callProcessAndLogOutput (sev_out, sev_err) process =

165 void $ withProcess process $ \out err -> do

164 void $ withProcess process $ \out err -> do

@@ -212,7 +211,7 @@ 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, MonadMask 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)

217withProcess process f =

216withProcess process f =

218 bracketOnError

217 bracketOnError

@@ -229,7 +228,7 @@ withProcess process f =

229

228

230-- | Runs a process to completion failing if it does not exit cleanly.

229-- | Runs a process to completion failing if it does not exit cleanly.

231runProcess_

230runProcess_

232− :: (MonadIO m, CliLog m, CliThrow e m, MonadMask m, AsProcessFailure e, MonadFail m)

231+ :: (MonadIO m, CliLog m, CliThrow e m, MonadMask m, AsProcessFailure e)

233 => ProcessSpec -> m ()

232 => ProcessSpec -> m ()

234runProcess_ process =

233runProcess_ process =

235 bracketOnError

234 bracketOnError

lib/command/obelisk-command.cabal+2−2

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

1name: obelisk-command

2−version: 0.8.0.0

2+version: 0.9.0.1

3cabal-version: >= 1.8

4build-type: Simple

5

@@ -66,4 +66,4 @@ library

66executable ob

67 main-is: src-bin/ob.hs

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/Deploy.hs+15−15

@@ -85,13 +85,12 @@ deployInit' thunkPtr (DeployInitOpts deployDir sshKeyPath hostnames route adminE

85 --accidentally create a production deployment that uses development

86 --credentials to connect to some resources. This could result in, e.g.,

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

178 , "&&"

179 , "/nix/var/nix/profiles/system/bin/switch-to-configuration switch"

@@ -182,10 +182,10 @@ deployPush deployPath getNixBuilders = do

182 isClean <- checkGitCleanStatus deployPath True

183 when (not isClean) $ 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

190 where

191 callProcess' envMap cmd args = do

@@ -315,7 +315,7 @@ readDeployConfig deployDir fname = liftIO $ do

315

316verifyHostKey :: MonadObelisk m => FilePath -> FilePath -> String -> m ()

317verifyHostKey knownHostsPath keyPath hostName =

318− callProcessAndLogOutput (Notice, Warning) $ proc "ssh" $

318+ callProcessAndLogOutput (Notice, Warning) $ proc sshPath $

319 sshArgs knownHostsPath keyPath True <>

320 [ "root@" <> hostName

321 , "-o", "NumberOfPasswordPrompts=0"

lib/command/src/Obelisk/Command/Preprocessor.hs+52−47

@@ -5,6 +5,7 @@ module Obelisk.Command.Preprocessor where

5

6import qualified Data.ByteString.Lazy as BL

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

32 packagePaths <- traverse canonicalizePath packagePaths'

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."

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

71 addDefaultLanguage =

72 case _cabalPackageInfo_defaultLanguage packageInfo of

73 Nothing -> id

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

78 EnableExtension ext -> [TL.fromString (show ext)]

79− DisableExtension _ -> []

79+ DisableExtension ext -> ["No" <> TL.fromString (show ext)]

80 UnknownExtension ext -> [TL.fromString ext]

81

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

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+10−4

@@ -51,7 +51,7 @@ import Obelisk.App (MonadObelisk)

51import Obelisk.CliApp

52import Obelisk.Command.Nix

53import Obelisk.Command.Thunk

54−import Obelisk.Command.Utils (nixBuildExePath, nixExePath, toNixPath)

54+import Obelisk.Command.Utils (nixBuildExePath, nixExePath, toNixPath, cp, nixShellPath)

55

56--TODO: Make this module resilient to random exceptions

57

@@ -116,7 +116,7 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do

116 skel <- nixBuildAttrWithCache implDir "skeleton" --TODO: I don't think there's actually any reason to cache this

117

118 callProcessAndLogOutput (Notice, Error) $

119− proc "cp"

119+ proc cp

120 [ "-r"

121 , "--preserve=links"

122 , obDir

@@ -126,7 +126,7 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do

126

127 withSpinner "Copying project skeleton" $ do

128 callProcessAndLogOutput (Notice, Error) $

129− proc "cp"

129+ proc cp

130 [ "-r"

131 , "--no-preserve=mode"

132 , "-T"

@@ -137,6 +137,12 @@ initProject source force = withSystemTempDirectory "ob-init" $ \tmpDir -> do

137 let configDir = "config"

138 createDirectoryIfMissing False configDir

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+ ]

140

146

141callHandoffOb

147callHandoffOb

142 :: MonadObelisk m

148 :: MonadObelisk m

@@ -292,7 +298,7 @@ bashEscape :: String -> String

292bashEscape = BSU.toString . bytes . bash . BSU.fromString

298bashEscape = BSU.toString . bytes . bash . BSU.fromString

293

299

294nixShellRunProc :: NixShellConfig -> ProcessSpec

300nixShellRunProc :: NixShellConfig -> ProcessSpec

295−nixShellRunProc cfg = setDelegateCtlc True $ proc "nix-shell" $ runNixShellConfig cfg

301+nixShellRunProc cfg = setDelegateCtlc True $ proc nixShellPath $ runNixShellConfig cfg

296

302

297nixShellWithoutPkgs

303nixShellWithoutPkgs

298 :: MonadObelisk m

304 :: MonadObelisk m

lib/command/src/Obelisk/Command/Run.hs+14−13

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

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

15import Control.Exception (Exception, bracket)

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

17−import Control.Monad (filterM, unless)

17+import Control.Monad (filterM)

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

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

20import Control.Monad.Reader (MonadIO)

@@ -46,7 +46,7 @@ import Distribution.Compiler (CompilerFlavor(..))

46import Distribution.PackageDescription.Parsec (parseGenericPackageDescription)

47import Distribution.Parsec.ParseResult (runParseResult)

48import qualified Distribution.System as Dist

49−import Distribution.Types.BuildInfo (buildable, defaultExtensions, defaultLanguage, hsSourceDirs, options)

49+import Distribution.Types.BuildInfo (buildable, cppOptions, defaultExtensions, defaultLanguage, hsSourceDirs, options)

50import Distribution.Types.CondTree (simplifyCondTree)

51import Distribution.Types.GenericPackageDescription (ConfVar (Arch, Impl, OS), condLibrary)

52import Distribution.Types.Library (libBuildInfo)

@@ -94,9 +94,11 @@ data CabalPackageInfo = CabalPackageInfo

94 -- ^ List of globally set languages of the library component

95 , _cabalPackageInfo_compilerOptions :: [(CompilerFlavor, [String])]

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)

97 }

99 }

98

100

99−-- | 'Bool' with a better name for it's purpose.

101+-- | 'Bool' with a better name for its purpose.

100data Interpret = Interpret_Interpret | Interpret_NoInterpret deriving (Eq, Ord, Show)

102data Interpret = Interpret_Interpret | Interpret_NoInterpret deriving (Eq, Ord, Show)

101

103

102textInterpret :: Interpret -> Text

104textInterpret :: Interpret -> Text

@@ -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'

lib/command/src/Obelisk/Command/Utils.hs+28−2

@@ -60,6 +60,32 @@ nixPrefetchGitPath = $(staticWhich "nix-prefetch-git")

60nixPrefetchUrlPath :: FilePath

61nixPrefetchUrlPath = $(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+

63-- | Nix syntax requires relative paths to be prefixed by @./@ or

89-- | Nix syntax requires relative paths to be prefixed by @./@ or

64-- @../@. 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

65-- expression.

91-- expression.

@@ -97,7 +123,7 @@ initGit repo = do

97 git ["commit", "-m", "Initial commit."]

123 git ["commit", "-m", "Initial commit."]

98

124

99gitProcNoRepo :: [String] -> ProcessSpec

125gitProcNoRepo :: [String] -> ProcessSpec

100−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

101

127

102gitProc :: FilePath -> [String] -> ProcessSpec

128gitProc :: FilePath -> [String] -> ProcessSpec

103gitProc repo = gitProcNoRepo . runGitInDir

129gitProc repo = gitProcNoRepo . runGitInDir

@@ -114,7 +140,7 @@ isolateGitProc = setEnvOverride (overrides <>)

114 , ("GIT_CONFIG_NOSYSTEM", "1")

140 , ("GIT_CONFIG_NOSYSTEM", "1")

115 , ("GIT_TERMINAL_PROMPT", "0") -- git 2.3+

141 , ("GIT_TERMINAL_PROMPT", "0") -- git 2.3+

116 , ("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

117− , ("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")

118 ]

144 ]

119

145

120-- | 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

22import Obelisk.App (MonadObelisk, getObeliskUserStateDir)

23import Obelisk.CliApp

24−import Obelisk.Command.Utils (rmPath)

24+import Obelisk.Command.Utils (rmPath, whichPath, sshKeygenPath, nixBuildExePath, dockerPath)

25

26-- | Generate the `--builders` argument string to enable the VM builder after ensuring it is available.

27getNixBuildersArg :: MonadObelisk m => m String

@@ -35,7 +35,7 @@ getNixBuildersArg = do

35

36checkForNixDarwin :: MonadObelisk m => String -> m ()

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"

40 [ "Deployments from macOS require nix-darwin to be installed."

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

68 containerNames <- fmap (map T.strip . T.lines) $

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

72 when exists $ testLinuxBuild stateDir

73 pure exists

@@ -85,7 +85,7 @@ containerSshPort = 2222

85startContainer :: MonadObelisk m => m ()

86startContainer = withSpinner "Starting VM builder" $

87 callProcessAndLogOutput (Debug, Debug) $

88− proc "docker" ["start", containerName]

88+ proc dockerPath ["start", containerName]

89

90-- | Creates the Docker container; assumes it does not exist.

91setupNixDocker :: MonadObelisk m => FilePath -> m ()

@@ -98,12 +98,12 @@ setupNixDocker stateDir = withSpinner ("Creating Docker container named " <> con

98 callProcessAndLogOutput (Debug, Error) $

99 proc rmPath ["-f", stateDir </> sshKeyFileName, stateDir </> sshKeyFileName <.> "pub"]

100 callProcessAndLogOutput (Debug, Error) $

101− proc "ssh-keygen" ["-t", "ed25519", "-f", stateDir </> sshKeyFileName, "-P", ""]

101+ proc sshKeygenPath ["-t", "ed25519", "-f", stateDir </> sshKeyFileName, "-P", ""]

102

103 -- Build the docker container (which uses the SSH keys in the 'ssh' folder)

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"

108 , "--restart", "always"

109 , "--detach"

@@ -155,7 +155,7 @@ testLinuxBuild :: MonadObelisk m => FilePath -> m ()

155testLinuxBuild stateDir

156 | System.Info.os == "linux" = failWith "Using the docker builder is not necessary on linux."

157 | otherwise = do

158− (exitCode, _stdout, stderr) <- readCreateProcessWithExitCode $ proc "nix-build"

158+ (exitCode, _stdout, stderr) <- readCreateProcessWithExitCode $ proc nixBuildExePath

159 [ "--no-out-link"

160 , "-E", "(import <nixpkgs> { system = \"x86_64-linux\"; }).writeText \"test\" builtins.currentTime"

161 , "--builders", nixBuildersArgString stateDir

lib/executable-config/default.nix+13−2

@@ -25,8 +25,19 @@ let

25in

26

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

16

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,

32 bytestring,

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

19 ) where

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:

27 Obelisk.Frontend

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,

21 jsaddle,

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+23−22

@@ -6,7 +6,6 @@

6{-# LANGUAGE FlexibleContexts #-}

7{-# LANGUAGE FlexibleInstances #-}

8{-# LANGUAGE GADTs #-}

9−{-# LANGUAGE KindSignatures #-}

10{-# LANGUAGE LambdaCase #-}

9{-# LANGUAGE LambdaCase #-}

11{-# LANGUAGE MultiParamTypeClasses #-}

10{-# LANGUAGE MultiParamTypeClasses #-}

12{-# LANGUAGE OverloadedStrings #-}

11{-# LANGUAGE OverloadedStrings #-}

@@ -141,16 +140,19 @@ import Control.Lens

141 , Wrapped (..)

140 , Wrapped (..)

142 )

141 )

143import Control.Monad.Except

142import Control.Monad.Except

144−import Control.Monad.Writer (execWriter, tell)

145import qualified Control.Monad.State.Strict as State

143import qualified Control.Monad.State.Strict as State

146import 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

147import qualified Data.ByteString as BS

148import qualified Data.ByteString as BS

148import qualified Data.ByteString.Lazy as BSL

149import qualified Data.ByteString.Lazy as BSL

149−import Data.Dependent.Sum (DSum (..))

150import Data.Dependent.Map (DMap)

151import qualified Data.Dependent.Map as DMap

152+import Data.Dependent.Sum (DSum (..))

152import Data.Either.Validation (Validation (..))

153import Data.Either.Validation (Validation (..))

153import Data.Foldable

154import Data.Foldable

155+import Data.Functor (($>))

154import Data.Functor.Sum

156import Data.Functor.Sum

155import Data.GADT.Compare

157import Data.GADT.Compare

156import Data.GADT.Compare.TH

158import Data.GADT.Compare.TH

@@ -163,19 +165,18 @@ import Data.Monoid ((<>))

163import Data.Set (Set)

165import Data.Set (Set)

164import qualified Data.Set as Set

166import qualified Data.Set as Set

165import Data.Some (Some(Some))

167import Data.Some (Some(Some))

168+import Data.Tabulation

166import Data.Text (Text)

169import Data.Text (Text)

167−import Data.Text.Lens (IsText, packed, unpacked)

168import qualified Data.Text as T

170import qualified Data.Text as T

169import 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

170import Data.Universe

174import Data.Universe

171import Data.Universe.Some

175import Data.Universe.Some

172import Network.HTTP.Types.URI

176import Network.HTTP.Types.URI

173import qualified Numeric.Lens

177import qualified Numeric.Lens

174import Obelisk.Route.TH

178import Obelisk.Route.TH

175import Text.Read (readMaybe)

179import Text.Read (readMaybe)

176−import Data.Tabulation

177−import qualified Data.Aeson as Aeson

178−import Data.Aeson (FromJSON, ToJSON)

179

180

180-- Design goals:

181-- Design goals:

181-- No start-up time on the frontend (not yet met)

182-- No start-up time on the frontend (not yet met)

@@ -303,13 +304,13 @@ decode e x = runIdentity (tryDecode e x)

303-- | 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

304-- 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.

305tryDecode :: Encoder Identity parse decoded encoded -> encoded -> parse decoded

306tryDecode :: Encoder Identity parse decoded encoded -> encoded -> parse decoded

306−tryDecode (Encoder (Identity impl)) x = _encoderImpl_decode impl x

307+tryDecode (Encoder (Identity impl)) = _encoderImpl_decode impl

307

308

308-- | 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

309-- 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,

310-- 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'

311encode :: Encoder Identity parse decoded encoded -> decoded -> encoded

312encode :: Encoder Identity parse decoded encoded -> decoded -> encoded

312−encode (Encoder (Identity impl)) x = _encoderImpl_encode impl x

313+encode (Encoder (Identity impl)) = _encoderImpl_encode impl

313

314

314-- | 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

315-- reasonably certain that the law given for 'EncoderImpl' above holds.

316-- reasonably certain that the law given for 'EncoderImpl' above holds.

@@ -554,11 +555,11 @@ pathComponentEncoder f = Encoder $ do

554 unEncoder (pathComponentEncoderImpl (enum1Encoder (extractPathSegment . f)) f')

555 unEncoder (pathComponentEncoderImpl (enum1Encoder (extractPathSegment . f)) f')

555

556

556pathComponentEncoderImpl :: forall check parse p. (Monad check, Monad parse)

557pathComponentEncoderImpl :: forall check parse p. (Monad check, Monad parse)

557− => (Encoder check parse (Some p) (Maybe Text))

558+ => Encoder check parse (Some p) (Maybe Text)

558 -> (forall a. p a -> Encoder Identity parse a PageName)

559 -> (forall a. p a -> Encoder Identity parse a PageName)

559 -> Encoder check parse (R p) PageName

560 -> Encoder check parse (R p) PageName

560−pathComponentEncoderImpl this rest =

561+pathComponentEncoderImpl =

561− chainEncoder (lensEncoder (\(_, b) a -> (a, b)) Prelude.fst consEncoder) this rest

562+ chainEncoder (lensEncoder (\(_, b) a -> (a, b)) Prelude.fst consEncoder)

562

563

563--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

564

565

@@ -814,7 +815,7 @@ rPrism

814 :: forall f f'

815 :: forall f f'

815 . (forall a. Prism' (f a) (f' a))

816 . (forall a. Prism' (f a) (f' a))

816 -> Prism' (R f) (R f')

817 -> Prism' (R f) (R f')

817−rPrism p = dSumPrism p

818+rPrism = dSumPrism

818

819

819dSumPrism'

820dSumPrism'

820 :: forall f g a

821 :: forall f g a

@@ -826,7 +827,7 @@ dSumGEqPrism

826 :: GEq f

827 :: GEq f

827 => f a

828 => f a

828 -> Prism' (DSum f g) (g a)

829 -> Prism' (DSum f g) (g a)

829−dSumGEqPrism variant = dSumPrism' $ prism' (\Refl -> variant) (\x -> geq variant x)

830+dSumGEqPrism variant = dSumPrism' $ prism' (\Refl -> variant) (geq variant)

830

831

831-- | 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

832-- 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'

@@ -993,9 +994,9 @@ obeliskRouteSegment r appRouteSegment = case r of

993-- 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'.

994resourceRouteSegment :: (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

995resourceRouteSegment = \case

996resourceRouteSegment = \case

996− ResourceRoute_Static -> PathSegment "static" $ pathOnlyEncoderIgnoringQuery

997+ ResourceRoute_Static -> PathSegment "static" pathOnlyEncoderIgnoringQuery

997− ResourceRoute_Ghcjs -> PathSegment "ghcjs" $ pathOnlyEncoder

998+ ResourceRoute_Ghcjs -> PathSegment "ghcjs" pathOnlyEncoder

998− ResourceRoute_JSaddleWarp -> PathSegment "jsaddle" $ jsaddleWarpRouteEncoder

999+ ResourceRoute_JSaddleWarp -> PathSegment "jsaddle" jsaddleWarpRouteEncoder

999 ResourceRoute_Version -> PathSegment "version" $ unitEncoder mempty

1000 ResourceRoute_Version -> PathSegment "version" $ unitEncoder mempty

1000

1001

1001data JSaddleWarpRoute :: * -> * where

1002data JSaddleWarpRoute :: * -> * where

@@ -1007,7 +1008,7 @@ jsaddleWarpRouteEncoder :: (MonadError Text check, MonadError Text parse) => Enc

1007jsaddleWarpRouteEncoder = pathComponentEncoder $ \case

1008jsaddleWarpRouteEncoder = pathComponentEncoder $ \case

1008 JSaddleWarpRoute_JavaScript -> PathSegment "jsaddle.js" $ unitEncoder mempty

1009 JSaddleWarpRoute_JavaScript -> PathSegment "jsaddle.js" $ unitEncoder mempty

1009 JSaddleWarpRoute_WebSocket -> PathEnd $ unitEncoder mempty

1010 JSaddleWarpRoute_WebSocket -> PathEnd $ unitEncoder mempty

1010− JSaddleWarpRoute_Sync -> PathSegment "sync" $ pathOnlyEncoder

1011+ JSaddleWarpRoute_Sync -> PathSegment "sync" pathOnlyEncoder

1011

1012

1012instance GShow appRoute => GShow (ObeliskRoute appRoute) where

1013instance GShow appRoute => GShow (ObeliskRoute appRoute) where

1013 gshowsPrec prec = \case

1014 gshowsPrec prec = \case

@@ -1038,8 +1039,8 @@ someSumEncoder = Encoder $ pure $ EncoderImpl

1038

1039

1039data Void1 :: * -> * where {}

1040data Void1 :: * -> * where {}

1040

1041

1041−instance Universe (Some Void1) where

1042+instance UniverseSome Void1 where

1042− universe = []

1043+ universeSome = []

1043

1044

1044void1Encoder :: (Applicative check, MonadError Text parse) => Encoder check parse (Some Void1) a

1045void1Encoder :: (Applicative check, MonadError Text parse) => Encoder check parse (Some Void1) a

1045void1Encoder = Encoder $ pure $ EncoderImpl

1046void1Encoder = Encoder $ pure $ EncoderImpl

@@ -1083,7 +1084,7 @@ readShowEncoder :: (MonadError Text parse, Read a, Show a, Applicative check) =>

1083readShowEncoder = singlePathSegmentEncoder . unsafeTshowEncoder

1084readShowEncoder = singlePathSegmentEncoder . unsafeTshowEncoder

1084

1085

1085integralEncoder :: (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

1086−integralEncoder = reviewEncoder (Numeric.Lens.integral)

1087+integralEncoder = reviewEncoder Numeric.Lens.integral

1087

1088

1088pathSegmentEncoder :: (MonadError Text parse, Applicative check, Cons as as a a) =>

1089pathSegmentEncoder :: (MonadError Text parse, Applicative check, Cons as as a a) =>

1089 Encoder check parse (a, (as, b)) (as, b)

1090 Encoder check parse (a, (as, b)) (as, b)

@@ -1158,7 +1159,7 @@ pathFieldEncoder fieldEncoder = unsafeEncoder $ do

1158 fieldEncoderPure f = toEncoder (DMap.findWithDefault (error "bad") f fieldEncoderPureMap)

1159 fieldEncoderPure f = toEncoder (DMap.findWithDefault (error "bad") f fieldEncoderPureMap)

1159 pure $ EncoderImpl

1160 pure $ EncoderImpl

1160 { _encoderImpl_encode = \(x, rest) -> execWriter $ do

1161 { _encoderImpl_encode = \(x, rest) -> execWriter $ do

1161− _ <- 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

1162 tell rest

1163 tell rest

1163 , _encoderImpl_decode = State.runStateT $ tabulateFieldsA $ \f -> State.get >>= \case

1164 , _encoderImpl_decode = State.runStateT $ tabulateFieldsA $ \f -> State.get >>= \case

1164 [] -> 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 #-}

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

23module Obelisk.Route.Frontend

24 ( module Obelisk.Route

@@ -57,49 +57,42 @@ module Obelisk.Route.Frontend

57

58import Prelude hiding ((.), id)

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

34 , ref-tf

35 , reflex

36− , reflex-dom

36+ , reflex-dom-core

37 , snap-core

38 , streaming-commons

39 , text

@@ -47,7 +47,7 @@ library

47 , websockets

48 exposed-modules:

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)

52 cpp-options: -DIPROUTE_SUPPORTED

53 build-depends: which

lib/run/src/Obelisk/Run.hs+3−3

@@ -144,9 +144,9 @@ runWidget conf configs frontend validFullEncoder = do

144

145 cert <- X509.newX509 >>= X509Request.makeX509FromReq certRequest

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

151

152 certByteString <- BSUTF8.fromString <$> PEM.writeX509 cert

lib/snap-extras/obelisk-snap-extras.cabal+1−1

@@ -17,4 +17,4 @@ library

17 , text

18 exposed-modules:

19 Obelisk.Snap.Extras

20− 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

18cachePermanently :: MonadSnap m => m ()

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"

22

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

15 exposed-modules:

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

19executable backend

20 main-is: main.hs

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:

2 *

3+write-ghc-environment-files: never

skeleton/common/common.cabal+1−1

@@ -12,4 +12,4 @@ library

12 exposed-modules:

13 Common.Api

14 Common.Route

15− ghc-options: -Wall

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+2−2

@@ -16,7 +16,7 @@ library

16 , text

17 exposed-modules:

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

21executable frontend

22 main-is: main.hs

@@ -28,7 +28,7 @@ executable frontend

28 , reflex-dom

29 , obelisk-generated-static

30 , frontend

31− ghc-options: -threaded

31+ ghc-options: -threaded -O -Wall -Wredundant-constraints -Wincomplete-uni-patterns -Wincomplete-record-updates -fno-show-valid-hole-fits

32 if impl(ghcjs)

33 ghc-options: -dedupe

34 cpp-options: -DGHCJS_BROWSER

skeleton/shell.nixdeleted−1

@@ -1 +0,0 @@

1−(import ./. {}).shells.ghc