{-# LANGUAGE ApplicativeDo         #-}
{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE DerivingStrategies    #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns        #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE QuasiQuotes           #-}
{-# LANGUAGE RecordWildCards       #-}

{-| @dhall-to-nixpkgs@ is essentially the Dhall analog of @cabal2nix@.

    The following Nix code is required reading for understanding how
    @dhall-to-nixpkgs@ is supposed to work:

    <https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/interpreters/dhall/build-dhall-package.nix>

    The Nixpkgs support for Dhall builds packages without using Dhall's support
    for HTTP(S) imports.  Instead, all remote packages are fetched by Nix
    (e.g. using @pkgs.fetchFromGitHub@) instead of being fetched by Dhall.  In
    fact, the Nix builder enforces that Dhall builds are offline by compiling
    the @dhall@ executable with the @-f-with-http@ configure flag to disable
    support for remote imports and then using that executable to build Dhall
    packages.

    Nix is able to build Dhall packages with remote imports by requiring that
    remote imports are protected with semantic integrity checks and then
    replacing the remote imports with cache hits.  So long as the correct
    dependency is added to `buildDhallPackage`'s `dependencies` argument then
    the builder will ensure that the dependency is present in the cache so that
    the remote import is elided.

    However, using `buildDhallPackage` to author a Dhall package is tedious,
    due to manual steps such as:

    * Discovering all of a Dhall package's remote dependencies and translating
      them to Nix code

    * For GitHub packages, computing the correct revision and hash

    @dhall-to-nixpkgs@ automates the generation of suitable Nix code, taking
    care of details such as these and more.  Note that @dhall-to-nixpkgs@
    technically uses the higher-level @buildDhall{GitHub,Directory}Package@
    utilities instead of the lower-level @buildDhallPackage@ in order to
    simplify the generated code, but the general idea is still the same.

    The Nixpkgs support for Dhall makes a simplifying assumption of a
    "consistent package set", meaning that even though there may be multiple
    buildable versions for a Dhall package there will always be a preferred
    version for every package (analogous to how a Stackage resolver selects
    default package versions for Haskell).  This means that the dependency list
    generated by @dhall-to-nixpkgs@ will not refer to specific versions or
    revisions of dependencies and will instead refer to the default preferred
    version.

    For example, if a package were to depend on both
    @https://prelude.dhall-lang.org/v10.0.0/package.dhall@ and
    @https://prelude.dhall-lang.org/v11.0.0/package.dhall@, @dhall-to-nixpkgs@
    would convert both of them to the same version-less @Prelude@ dependency
    (which would select the default Prelude version).  That in turn would
    inevitably fail to satisfy one or the other dependency.

    This implies that @dhall-to-nixpkgs@ does not support packages that depend
    on multiple versions of the same dependency.  We could technically support
    this, but for now the tool will discourage that.  Users that really want to
    depend on a specific version of a dependency can still manually edit
    the code generated by @dhall-to-nixpkgs@ if they insist.
-}

module Main where

import Control.Applicative              (empty, optional, (<|>))
import Control.Monad.IO.Class           (MonadIO (..))
import Control.Monad.Morph              (hoist)
import Control.Monad.Trans.Class        (lift)
import Control.Monad.Trans.State.Strict (StateT)
import Data.Aeson                       (FromJSON)
import Data.Fix                         (Fix)
import Data.List.NonEmpty               (NonEmpty (..))
import Data.Text                        (Text)
import Data.Void                        (Void)
import Dhall.Import                     (Status (..), stack)
import Dhall.Parser                     (Src)
import GHC.Generics                     (Generic)
import Lens.Family.State.Strict         (zoom)
import Network.URI                      (URI (..), URIAuth (..))
import Nix.Expr.Shorthands              ((@.), (@@))
import Nix.Expr.Types                   (NExpr)
import Options.Applicative              (Parser, ParserInfo)
import Prelude                          hiding (FilePath)
import System.Exit                      (ExitCode (..))
import Text.Megaparsec                  (Parsec)
import Turtle                           (FilePath, Shell, fp, (</>))

import Dhall.Core
    ( Expr (..)
    , File (..)
    , Import (..)
    , ImportHashed (..)
    , ImportMode (..)
    , ImportType (..)
    , URL (..)
    )

import qualified Control.Foldl                         as Foldl
import qualified Control.Monad.Trans.State.Strict      as State
import qualified Data.Aeson                            as Aeson
import qualified Data.Foldable                         as Foldable
import qualified Data.List.NonEmpty                    as NonEmpty
import qualified Data.Text                             as Text
import qualified Data.Text.Encoding                    as Text.Encoding
import qualified Data.Text.IO                          as Text.IO
import qualified Data.Text.Prettyprint.Doc.Render.Text as Prettyprint.Text
import qualified Dhall.Core
import qualified Dhall.Import
import qualified Dhall.Optics
import qualified Dhall.Parser
import qualified GHC.IO.Encoding
import qualified NeatInterpolation
import qualified Network.URI                           as URI
import qualified Nix.Expr.Shorthands                   as Nix
import qualified Nix.Pretty
import qualified Options.Applicative                   as Options
import qualified System.Exit
import qualified System.IO
import qualified Text.Megaparsec                       as Megaparsec
import qualified Text.Megaparsec.Char                  as Megaparsec.Char
import qualified Text.Megaparsec.Char.Lexer            as Megaparsec.Char.Lexer
import qualified Turtle

data Options
    = OptionsGitHub GitHub
    | OptionsDirectory Directory

data GitHub = GitHub
    { name :: Maybe Text
    , uri :: Text
    , rev :: Maybe Text
    , hash :: Maybe Text
    , fetchSubmodules :: Bool
    , directory :: FilePath
    , file :: FilePath
    , source :: Bool
    }

data Directory = Directory
    { name :: Maybe Text
    , directory :: FilePath
    , file :: FilePath
    , source :: Bool
    }

data NixPrefetchGit = NixPrefetchGit
    { url :: Text
    , rev :: Text
    , path :: Text
    , sha256 :: Text
    }
    deriving stock (Generic)
    deriving anyclass (FromJSON)

parseOptions :: Parser Options
parseOptions =
        subcommand
            "github"
            "Create a Nix package from a GitHub repository"
            (fmap OptionsGitHub parseGitHub)
    <|> subcommand
            "directory"
            "Create a Nix package from a local directory"
            (fmap OptionsDirectory parseDirectory)
  where
    subcommand name description parser =
        Options.hsubparser
            (   Options.command name parserInfo
            <>  Options.metavar name
            )
      where
        parserInfo =
            Options.info parser
                (   Options.fullDesc
                <>  Options.progDesc description
                )

parseFile :: Parser FilePath
parseFile =
    Options.strOption
        (   Options.long "file"
        <>  Options.help "File to import, relative to the top-level directory"
        <>  Options.value "package.dhall"
        )

parseSource :: Parser Bool
parseSource =
    Options.switch
        (   Options.long "source"
        <>  Options.help "Configure the Nix package to include source code"
        )

parseName :: Parser (Maybe Text)
parseName =
    optional
        (Options.strOption
            (   Options.long "name"
            <>  Options.help "Name for the Nix derivation"
            )
        )

parseGitHub :: Parser GitHub
parseGitHub = do
    name <- parseName

    uri <- Options.strArgument (Options.metavar "URL")

    rev <- do
        optional
            (Options.strOption
                (   Options.long "rev"
                <>  Options.help "Git revision to use"
                )
            )

    hash <- do
        optional
            (Options.strOption
                (   Options.long "hash"
                <>  Options.help "Expected SHA256 hash"
                )
            )

    fetchSubmodules <-
        Options.switch
            (   Options.long "fetch-submodules"
            <>  Options.help "Fetch git submodules"
            )

    directory <-
        Options.strOption
            (   Options.long "directory"
            <>  Options.help "Subdirectory containing the Dhall package"
            <>  Options.value ""
            )

    file <- parseFile

    source <- parseSource

    return GitHub{..}

parseDirectory :: Parser Directory
parseDirectory = do
    name <- parseName

    directory <- Options.strArgument (Options.metavar "DIRECTORY")

    file <- parseFile

    source <- parseSource

    return Directory{..}

parserInfoOptions :: ParserInfo Options
parserInfoOptions =
    Options.info
        (Options.helper <*> parseOptions)
        (   Options.progDesc "Convert a Dhall project to a Nix package"
        <>  Options.fullDesc
        )

main :: IO ()
main = do
    GHC.IO.Encoding.setLocaleEncoding System.IO.utf8

    options <- Options.execParser parserInfoOptions

    case options of
        OptionsGitHub    github    -> githubToNixpkgs    github
        OptionsDirectory directory -> directoryToNixpkgs directory

-- | Convenient utility for generating command-line options
toListWith :: (a -> [ Text ]) -> Maybe a -> [ Text ]
toListWith f (Just x ) = f x
toListWith _  Nothing  = [ ]

nub :: Ord a => [a] -> [a]
nub = Foldl.fold Foldl.nub

{-| This specialization of `nub` is necessary to work around a type-checking
    loop with GHC 8.4
-}
nub'
    :: Ord (f (Fix f)) => [ (Text, Maybe (Fix f)) ] -> [ (Text, Maybe (Fix f)) ]
nub' = nub

{-| The Nixpkgs support for Dhall essentially replaces all remote imports with
    cache hits, but doing so implies that all remote imports must be protected
    by an integrity check.

    This function finds all remote imports that are transitive dependencies of
    the given expression, failing if any of them are missing integrity checks.
-}
findExternalDependencies :: Expr Src Import -> StateT Status Shell URL
findExternalDependencies expression = do
    -- This is a best-effort attempt to pick an import alternative if there is
    -- more than one
    let pickAlt (ImportAlt e0 e1)
            -- If only the latter import has an integrity check, then select
            -- that
            | Embed Import{ importHashed = ImportHashed{ hash = Nothing } } <- Dhall.Core.shallowDenote e0
            , Embed Import{ importHashed = ImportHashed{ hash = Just _  } } <- Dhall.Core.shallowDenote e1 =
                Just e1
            -- Otherwise prefer the first import
            | otherwise =
                Just e0
        pickAlt _ =
            Nothing

    let rewrittenExpression =
            Dhall.Optics.rewriteOf Dhall.Core.subExpressions pickAlt expression

    import_ <- lift (Turtle.select (Foldable.toList rewrittenExpression))

    parent :| _ <- zoom stack State.get

    child <- hoist liftIO (Dhall.Import.chainImport parent import_)

    let Import{ importHashed, importMode } = Dhall.Import.chainedImport child

    let ImportHashed{ hash, importType } = importHashed

    case importMode of
        Code     -> return ()
        RawText  -> return ()
        Location -> empty  -- "as Location" imports aren't real dependencies

    case importType of
        Missing ->
            empty

        Env {} ->
            empty

        Remote url ->
            case hash of
                Just _ ->
                    return url
                Nothing ->
                    die (MissingSemanticIntegrityCheck url)

        Local filePrefix file -> do
            filepath <- liftIO (Dhall.Import.localToPath filePrefix file)

            expressionText <- liftIO (Text.IO.readFile filepath)

            parsedExpression <- Dhall.Core.throws (Dhall.Parser.exprFromText filepath expressionText)

            zoom stack (State.modify (NonEmpty.cons child))

            findExternalDependencies parsedExpression

data Dependency = Dependency
    { functionParameter :: (Text, Maybe NExpr)
      -- ^ Function parameter used to bring the dependency into scope for the
      --   Nix package.  The @`Maybe` `NExpr`@ is always `Nothing`, but we
      --   include it here for convenience
    , dependencyExpression :: NExpr
      -- ^ The dependency expression to include in the dependency list.  This
      --   will be an expression of the form:
      --
      --   > someDependency.override { file = "./someFile.dhall" }
    }

{-| The Nixpkgs support for Dhall implements two conventions that
    @dhall-to-nixpkgs@ depends on:

    * Packages are named after their repository name
    * You can import a specific file using `packageName.override { file = …; }`

    This function is responsible for converting Dhall imports to package
    names and files that follow this convention.  For example, given a Dhall
    import like:

        https://raw.githubusercontent.com/EarnestResearch/dhall-packages/master/kubernetes/k8s/1.14.dhall

    ... this will create the corresponding Nix dependency of the form:

        dhall-packages.override { file = "kubernetes/k8s/1.14.dhall"; }
-}
dependencyToNix :: URL -> IO Dependency
dependencyToNix url@URL{ authority, path } = do
    let prelude = "Prelude"

    case authority of
        "raw.githubusercontent.com" -> do
            let File{ directory, file } = path

            let Dhall.Core.Directory{ components } = directory

            case reverse (file : components) of
                -- Special case to recognize a Prelude import and treat it as if
                -- it were an import of prelude.dhall-lang.org
                "dhall-lang" : "dhall-lang" : _rev : "Prelude" : rest -> do
                    let fileArgument = Text.intercalate "/" rest

                    let functionParameter = (prelude, Nothing)

                    let dependencyExpression =
                                (Nix.mkSym prelude @. "override")
                            @@  Nix.attrsE
                                    [ ("file", Nix.mkStr fileArgument ) ]

                    return Dependency{..}

                _owner : repo : _rev : rest -> do
                    let fileArgument = Text.intercalate "/" rest

                    let functionParameter = (repo, Nothing)

                    let dependencyExpression =
                                (Nix.mkSym repo @. "override")
                            @@  Nix.attrsE
                                    [ ("file", Nix.mkStr fileArgument ) ]

                    return Dependency{..}

                _ -> do
                    die (NotAValidGitHubRepositoryURL url)

        "prelude.dhall-lang.org" -> do
            let File{ directory, file } = path

            let Dhall.Core.Directory{ components } = directory

            let component :: Parsec Void Text Integer
                component = Megaparsec.Char.Lexer.decimal

            let version :: Parsec Void Text ()
                version = do
                    _ <- Megaparsec.Char.char 'v'
                    _ <- component
                    _ <- Megaparsec.Char.char '.'
                    _ <- component
                    _ <- Megaparsec.Char.char '.'
                    _ <- component
                    return ()

            let pathComponents =
                    case reverse (file : components) of
                        first : rest
                            -- Ignore the version.  The Nixpkgs support assumes
                            -- a curated set of package versions.
                            | Just _ <- Megaparsec.parseMaybe version first ->
                                rest
                        rest ->
                            rest
                        
            let fileArgument = Text.intercalate "/" pathComponents

            let functionParameter = (prelude, Nothing)

            let dependencyExpression =
                        (Nix.mkSym prelude @. "override")
                    @@  Nix.attrsE

                            [ ("file", Nix.mkStr fileArgument) ]

            return Dependency{..}
        _ -> do
            die (UnsupportedDomainDependency url authority)

githubToNixpkgs :: GitHub -> IO ()
githubToNixpkgs GitHub{ name, uri, rev = maybeRev, hash, fetchSubmodules, directory, file, source } = do
    URI{ uriScheme, uriAuthority = Just URIAuth{ uriUserInfo, uriRegName, uriPort }, uriPath, uriQuery, uriFragment } <- do
        case URI.parseAbsoluteURI (Text.unpack uri) of
            Nothing -> die (RepositoryIsNotAValidURI uri)
            Just u  -> return u

    case uriScheme of
        "https:" -> return ()
        _        -> die (UnsupportedURIScheme uri uriScheme)

    case uriRegName of
        "github.com" -> return ()
        _            -> die (UnsupportedDomain uri uriRegName)

    case uriPort of
        "" -> return ()
        _  -> die (UnsupportedPort uri uriPort)

    case uriQuery of
        "" -> return ()
        _  -> die (UnsupportedQuery uri uriQuery)

    case uriFragment of
        "" -> return ()
        _  -> die (UnsupportedFragment uri uriFragment)

    let githubBase = Text.pack (uriUserInfo <> uriRegName <> uriPort)

    let parsePath :: Parsec Void String (Text, Text)
        parsePath = do
            _ <- Megaparsec.Char.char '/'

            owner <- Megaparsec.takeWhile1P Nothing (/= '/')

            _ <- Megaparsec.Char.char '/'

            repo <- Megaparsec.takeWhile1P Nothing (/= '.')

            optional (Megaparsec.Char.string ".git")

            return (Text.pack owner, Text.pack repo)

    (owner, repo) <- case Megaparsec.parseMaybe parsePath uriPath of
        Nothing -> die (NotAValidGitHubRepository uri)

        Just (owner, repo) -> do
            return (owner, repo)

    let baseUrl =
            Text.pack uriScheme <> "//" <> githubBase <> "/" <> owner <> "/" <> repo

    (rev, sha256, repository) <- case maybeRev of
        Just r | not fetchSubmodules -> do
            let archiveURL = baseUrl <> "/archive/" <> r <> ".tar.gz"

            let args =  [ "--unpack"
                        , "--type", "sha256"
                        , "--print-path"
                        , "--name", repo
                        , archiveURL
                        ]
                    <>  toListWith (\t -> [ t ]) hash

            (exitCode, text) <- Turtle.procStrict "nix-prefetch-url" args empty

            case exitCode of
                ExitSuccess   -> return ()
                ExitFailure _ -> die (FailedToFetchGitHubArchive args)

            case Text.lines text of
                [ sha256, path ] -> return (r, sha256, Turtle.fromText path)
                _                -> die (FailedToParseNixPrefetchURL args)

        _ -> do
            let args =  [ "--url", baseUrl <> ".git"
                        , "--quiet"
                        ]
                    <>  toListWith (\t -> [ "--rev", t ]) maybeRev
                    <>  toListWith (\t -> [ "--hash", t ]) hash
                    <>  (if fetchSubmodules then [ "--fetch-submodules" ] else [])

            (exitCode, text) <- Turtle.procStrict "nix-prefetch-git" args empty

            case exitCode of
                ExitSuccess   -> return ()
                ExitFailure _ -> die (FailedToCloneRepository args)

            let bytes = Text.Encoding.encodeUtf8 text

            NixPrefetchGit{ rev, sha256, path } <- case Aeson.eitherDecodeStrict' bytes of
                Left message -> do
                    die (FailedToParseNixPrefetchGit args message)
                Right n -> do
                    return n

            return (rev, sha256, Turtle.fromText path)

    let finalName =
            case name of
                Nothing -> repo
                Just n  -> n

    let expressionFile = repository </> directory </> file

    let baseDirectory = Turtle.directory expressionFile

    let baseDirectoryString = Turtle.encodeString baseDirectory

    exists <- Turtle.testfile expressionFile

    if exists
        then return ()
        else die (MissingFile expressionFile)

    expressionText <- Turtle.readTextFile expressionFile

    expression <- Dhall.Core.throws (Dhall.Parser.exprFromText baseDirectoryString expressionText)

    let status = Dhall.Import.emptyStatus baseDirectoryString

    dependencies <- Turtle.reduce Foldl.nub (State.evalStateT (findExternalDependencies expression) status)

    nixDependencies <- traverse dependencyToNix dependencies

    let buildDhallGitHubPackage = "buildDhallGitHubPackage"

    let nixExpression =
            Nix.mkFunction
                (Nix.mkParamset
                    (   [ (buildDhallGitHubPackage, Nothing) ]
                    <>  nub' (fmap functionParameter nixDependencies)
                    )
                    False
                )
                (   Nix.mkSym buildDhallGitHubPackage
                @@  Nix.attrsE
                        [ ("name", Nix.mkStr finalName)
                        , ("githubBase", Nix.mkStr githubBase)
                        , ("owner", Nix.mkStr owner)
                        , ("repo", Nix.mkStr repo)
                        , ("rev", Nix.mkStr rev)
                        , ("fetchSubmodules", Nix.mkBool fetchSubmodules)
                        -- TODO: Support `private` / `varBase` options
                        , ("sha256", Nix.mkStr sha256)
                        , ("directory", Nix.mkStr (Turtle.format fp directory))
                        , ("file", Nix.mkStr (Turtle.format fp file))
                        , ("source", Nix.mkBool source)
                        , ("dependencies", Nix.mkList (nub (fmap dependencyExpression nixDependencies)))
                        ]
                )

    Prettyprint.Text.putDoc ((Nix.Pretty.prettyNix nixExpression) <> "\n")

directoryToNixpkgs :: Directory -> IO ()
directoryToNixpkgs Directory{ name, directory, file, source } = do
    let finalName =
            case name of
                Nothing -> Turtle.format fp (Turtle.dirname directory)
                Just n  -> n

    let expressionFile = directory </> file

    exists <- Turtle.testfile expressionFile

    if exists
        then return ()
        else do
            die (MissingFile expressionFile)

    expressionText <- Turtle.readTextFile expressionFile

    let directoryString = Turtle.encodeString directory

    expression <- Dhall.Core.throws (Dhall.Parser.exprFromText directoryString expressionText)

    let status = Dhall.Import.emptyStatus directoryString

    dependencies <- Turtle.reduce Foldl.nub (State.evalStateT (findExternalDependencies expression) status)

    nixDependencies <- traverse dependencyToNix dependencies

    let buildDhallDirectoryPackage = "buildDhallDirectoryPackage"

    let src | null directoryString        = directoryString
            | last directoryString == '/' = init directoryString
            | otherwise                   = directoryString

    let nixExpression =
            Nix.mkFunction
                (Nix.mkParamset
                    (   [ (buildDhallDirectoryPackage, Nothing) ]
                    <>  nub' (fmap functionParameter nixDependencies)
                    )
                    False
                )
                (   Nix.mkSym buildDhallDirectoryPackage
                @@  Nix.attrsE
                        [ ("name", Nix.mkStr finalName)
                        , ("src", Nix.mkPath False src)
                        , ("file", Nix.mkStr (Turtle.format fp file))
                        , ("source", Nix.mkBool source)
                        , ("dependencies", Nix.mkList (nub (fmap dependencyExpression nixDependencies)))
                        ]
                )

    Prettyprint.Text.putDoc ((Nix.Pretty.prettyNix nixExpression) <> "\n")

die :: MonadIO io => Error -> io a
die e = liftIO $ do
    Text.IO.hPutStrLn System.IO.stderr (renderError e)

    System.Exit.exitFailure

data Error
    = MissingSemanticIntegrityCheck URL
    | NotAValidGitHubRepositoryURL URL
    | UnsupportedDomainDependency URL Text
    | RepositoryIsNotAValidURI Text
    | UnsupportedURIScheme Text String
    | UnsupportedDomain Text String
    | UnsupportedPort Text String
    | UnsupportedQuery Text String
    | UnsupportedFragment Text String
    | NotAValidGitHubRepository Text
    | FailedToFetchGitHubArchive [Text]
    | FailedToParseNixPrefetchURL [Text]
    | FailedToCloneRepository [Text]
    | FailedToParseNixPrefetchGit [Text] String
    | MissingFile FilePath
    
renderError :: Error -> Text
renderError e = case e of
    MissingSemanticIntegrityCheck url ->
        let dependency = Dhall.Core.pretty url

        in  [NeatInterpolation.text|
Error: Dependency missing a semantic integrity check

Dhall's Nixpkgs requires that all of your remote dependencies are protected by
by semantic integrity checks.  This ensures that Nix can replace the remote
imports with cached imports built by Nix instead of the imports being fetched
via HTTP requests using Dhall.

The following dependency is missing a semantic integrity check:

↳ $dependency
|]

    NotAValidGitHubRepositoryURL url ->
        let dependency = Dhall.Core.pretty url

        in  [NeatInterpolation.text|
Error: Not a valid GitHub repository URL

Your Dhall package appears to depend on the following import:

↳ $dependency

... which is missing one or more path components that a raw GitHub import would
normally have.  The URL should minimally have the following path components:

↳ https://raw.githubusercontent.com/$${owner}/$${repository}/$${revision}/…
|]

    UnsupportedDomainDependency url authority ->
        let dependency = Dhall.Core.pretty url

        in  [NeatInterpolation.text|
Error: Unsupported domain

This tool currently only translates the following domains into Nix dependencies:

* raw.githubusercontent.com
* prelude.dhall-lang.org

One of the Dhall project's dependencies:

↳ $dependency

... used the following unexpected domain:

↳ $authority

If you would like to support a new domain for Dhall dependencies, please open an
issue here:

↳ https://github.com/dhall-lang/dhall-haskell/issues
|]

    RepositoryIsNotAValidURI uri ->
        [NeatInterpolation.text|
Error: The specified repository is not a valid URI

You provided the following argument:

↳ $uri

... which is not a valid URI
|]
    UnsupportedURIScheme uri uriScheme ->
        let uriSchemeText = Text.pack uriScheme

        in  [NeatInterpolation.text|
Error: URI schemes other than https are not supported

You specified the following URI:

↳ $uri

... which has the following scheme:

↳ $uriSchemeText

... which is not https
|]

    UnsupportedDomain uri uriRegName ->
        let uriRegNameText = Text.pack uriRegName

        in  [NeatInterpolation.text|
Error: Domains other than github.com are not supported

You specified the following URI:

↳ $uri

... which has the following domain:

↳ $uriRegNameText

... which is not github.com
|]

    UnsupportedPort uri uriPort ->
        let uriPortText = Text.pack uriPort

        in  [NeatInterpolation.text|
Error: Non-default ports are not supported

You specified the following URI:

↳ $uri

... which has the following explicit port specification:

↳ $uriPortText

... which is not permitted by this tool
|]

    UnsupportedQuery uri uriQuery ->
        let uriQueryText = Text.pack uriQuery

        in  [NeatInterpolation.text|
Error: Non-empty query strings are not supported

You specified the following URI:

↳ $uri

... which has the following query string:

↳ $uriQueryText

... which is not permitted by this tool
|]

    UnsupportedFragment uri uriFragment ->
        let uriFragmentText = Text.pack uriFragment

        in  [NeatInterpolation.text|
Error: Non-empty query fragments are not supported

You specified the following URI:

↳ $uri

... which has the following query fragment:

↳ $uriFragmentText

... which is not permitted by this tool
|]

    NotAValidGitHubRepository uri ->
        [NeatInterpolation.text|
Error: Not a valid GitHub repository

You specified the following URI:

↳ $uri

... which is not a valid GitHub repository.  A valid repository must match the
following format:

↳ https://github.com/$${owner}/$${repository}[.git]
|]

    FailedToFetchGitHubArchive args ->
        let argsText = Text.intercalate " " args

        in  [NeatInterpolation.text|
Error: Failed to fetch the GitHub's repository archive

The following command failed to fetch the following archive for the repository:

    nix-prefetch-url $argsText
|]

    FailedToParseNixPrefetchURL args ->
        let argsText = Text.intercalate " " args

        in  [NeatInterpolation.text|
Error: Failed to parse the nix-prefetch-url output

The following command:

    nix-prefetch-url $argsText

... should have produced two lines of output:

* First the SHA256 hash of the GitHub project
* Then the /nix/store/… path of the downloaded project

However, the output did not match, possibly indicating an internal error, either
with this tool or with nix-prefetch-url
|]

    FailedToCloneRepository args ->
        let argsText = Text.intercalate " " args

        in  [NeatInterpolation.text|
Error: Failed to clone the GitHub repository

The following command failed to clone the repository:

    nix-prefetch-git $argsText
|]

    FailedToParseNixPrefetchGit args message ->
        let argsText = Text.intercalate " " args

            messageText = Text.pack message

        in  [NeatInterpolation.text|
Error: Failed to parse the output of nix-prefetch-git

The following command:

    nix-prefetch-git $argsText

... should have produced a JSON output matching the following shape:

↳ { url : Text
  , rev : Text
  , path : Text
  , sha256 : Text
  , fetchSubmodules : Bool 
  }

... but JSON decoding failed with the following error:

↳ $messageText
|]

    MissingFile expressionFile ->
        let expressionFileText = Turtle.format fp expressionFile

        in  [NeatInterpolation.text|
Error: Missing file

The following file does not exist:

↳ $expressionFileText

Perhaps you meant to specify a different file within the project using the
--file option?
|]