Move split source into src/ and lib/

8 files changed, 0 insertions, 1052 deletions

diff --git a/CabalHelper/Compiletime/Compat/Environment.hs b/CabalHelper/Compiletime/Compat/Environment.hs
deleted file mode 100644
index 916f782..0000000
--- a/CabalHelper/Compiletime/Compat/Environment.hs
+++ /dev/null
@@ -1,6 +0,0 @@
-module CabalHelper.Compiletime.Compat.Environment where
-
-import System.Environment
-
-lookupEnv :: String -> IO (Maybe String)
-lookupEnv var = do env <- getEnvironment; return (lookup var env)
diff --git a/CabalHelper/Compiletime/Compat/Version.hs b/CabalHelper/Compiletime/Compat/Version.hs
deleted file mode 100644
index 853aca5..0000000
--- a/CabalHelper/Compiletime/Compat/Version.hs
+++ /dev/null
@@ -1,25 +0,0 @@
-{-# LANGUAGE CPP #-}
-module CabalHelper.Compiletime.Compat.Version
-    ( DataVersion
-    , toDataVersion
-    , fromDataVersion
-    , Data.Version.showVersion
-    ) where
-
-import qualified Data.Version
-import qualified Distribution.Version (Version)
-#if MIN_VERSION_Cabal(2,0,0)
-import qualified Distribution.Version  (versionNumbers, mkVersion)
-#endif
-
-type DataVersion = Data.Version.Version
-
-toDataVersion :: Distribution.Version.Version -> Data.Version.Version
-fromDataVersion :: Data.Version.Version -> Distribution.Version.Version
-#if MIN_VERSION_Cabal(2,0,0)
-toDataVersion v = Data.Version.Version (Distribution.Version.versionNumbers v) []
-fromDataVersion (Data.Version.Version vs _) = Distribution.Version.mkVersion vs
-#else
-toDataVersion = id
-fromDataVersion = id
-#endif
diff --git a/CabalHelper/Compiletime/Compile.hs b/CabalHelper/Compiletime/Compile.hs
deleted file mode 100644
index 8cc565e..0000000
--- a/CabalHelper/Compiletime/Compile.hs
+++ /dev/null
@@ -1,595 +0,0 @@
--- Copyright (C) 2015,2017  Daniel Gröber <dxld ÄT darkboxed DOT org>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU Affero General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Affero General Public License for more details.
---
--- You should have received a copy of the GNU Affero General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-{-# LANGUAGE RecordWildCards, FlexibleContexts #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Compile
-Description : Runtime compilation machinery
-License     : AGPL-3
--}
-
-module CabalHelper.Compiletime.Compile where
-
-import Control.Applicative
-import Control.Arrow
-import Control.Exception as E
-import Control.Monad
-import Control.Monad.Trans.Maybe
-import Control.Monad.IO.Class
-import Data.Traversable
-import Data.Char
-import Data.List
-import Data.Maybe
-import Data.String
-import Data.Version
-import GHC.IO.Exception (IOErrorType(OtherError))
-import Text.Printf
-import System.Directory
-import System.FilePath
-import System.Process
-import System.Exit
-import System.IO
-import System.IO.Error
-import System.IO.Temp
-import Prelude
-
-import Distribution.System (buildPlatform)
-import Distribution.Text (display)
-
-import Paths_cabal_helper (version)
-import CabalHelper.Compiletime.Data
-import CabalHelper.Compiletime.Log
-import CabalHelper.Compiletime.Types
-import CabalHelper.Shared.Common
-import CabalHelper.Shared.Sandbox (getSandboxPkgDb)
-
-data Compile = Compile {
-      compCabalSourceDir :: Maybe CabalSourceDir,
-      compPackageDb      :: Maybe PackageDbDir,
-      compCabalVersion   :: Either String Version,
-      compPackageDeps    :: [String]
-    }
-
-compileHelper :: Options -> Version -> FilePath -> FilePath -> IO (Either ExitCode FilePath)
-compileHelper opts cabalVer projdir distdir = do
-  case cabalPkgDb opts of
-    Nothing ->
-      run [ compileCabalSource
-          , Right <$> MaybeT (cachedExe cabalVer)
-          , compileSandbox
-          , compileGlobal
-          , cachedCabalPkg
-          , MaybeT (Just <$> compilePrivatePkgDb)
-          ]
-    mdb ->
-      run [ Right <$> MaybeT (cachedExe cabalVer)
-          , liftIO $ compileWithPkg mdb cabalVer
-          ]
-
- where
-   run actions = fromJust <$> runMaybeT (msum actions)
-
-   logMsg = "compiling helper with Cabal from "
-
--- for relaxed deps: find (sameMajorVersionAs cabalVer) . reverse . sort
-
-   -- | Check if this version is globally available
-   compileGlobal :: MaybeT IO (Either ExitCode FilePath)
-   compileGlobal = do
-       ver <- MaybeT $ find (== cabalVer) <$> listCabalVersions opts
-       vLog opts $ logMsg ++ "user/global package-db"
-       liftIO $ compileWithPkg Nothing ver
-
-   -- | Check if this version is available in the project sandbox
-   compileSandbox :: MaybeT IO (Either ExitCode FilePath)
-   compileSandbox = do
-       let ghcVer = ghcVersion opts
-           mdb_path = getSandboxPkgDb projdir (display buildPlatform) =<< ghcVer
-       sandbox <- PackageDbDir <$> MaybeT mdb_path
-       ver <- MaybeT $ logIOError opts "compileSandbox" $
-         find (== cabalVer) <$> listCabalVersions' opts (Just sandbox)
-       vLog opts $ logMsg ++ "sandbox package-db"
-       liftIO $ compileWithPkg (Just sandbox) ver
-
-
-   -- | Check if we already compiled this version of cabal into a private
-   -- package-db
-   cachedCabalPkg :: MaybeT IO (Either ExitCode FilePath)
-   cachedCabalPkg = do
-       db_exists <- liftIO $ cabalVersionExistsInPkgDb opts cabalVer
-       case db_exists of
-         False -> mzero
-         True -> do
-             db@(PackageDbDir db_path)
-                 <- liftIO $ getPrivateCabalPkgDb opts (Right cabalVer)
-             vLog opts $ logMsg ++ "private package-db in " ++ db_path
-             liftIO $ compileWithPkg (Just db) cabalVer
-
-   -- | See if we're in a cabal source tree
-   compileCabalSource :: MaybeT IO (Either ExitCode FilePath)
-   compileCabalSource = do
-       let cabalFile = projdir </> "Cabal.cabal"
-       cabalSrc <- liftIO $ doesFileExist cabalFile
-       let projdir' = CabalSourceDir projdir
-       case cabalSrc of
-         False -> mzero
-         True -> liftIO $ do
-           vLog opts $ "directory above distdir looks like cabal source tree (Cabal.cabal exists)"
-           ver <- cabalFileVersion <$> readFile cabalFile
-           vLog opts $ "compiling helper with local Cabal source tree"
-           compileWithCabalTree ver projdir'
-
-   -- | Compile the requested cabal version into an isolated package-db
-   compilePrivatePkgDb :: IO (Either ExitCode FilePath)
-   compilePrivatePkgDb = do
-       db <- fst <$> installCabal opts (Right cabalVer) `E.catch`
-             \(SomeException _) -> errorInstallCabal cabalVer distdir
-       compileWithPkg (Just db) cabalVer
-
-   compileWithCabalTree ver srcDir =
-       compile distdir opts $ Compile {
-                     compCabalSourceDir       = Just srcDir,
-                     compPackageDb            = Nothing,
-                     compCabalVersion         = Right ver,
-                     compPackageDeps          = []
-                   }
-
-   compileWithPkg mdb ver =
-       compile distdir opts $ Compile {
-                     compCabalSourceDir       = Nothing,
-                     compPackageDb            = mdb,
-                     compCabalVersion         = Right ver,
-                     compPackageDeps          = [cabalPkgId ver]
-                   }
-
-   cabalPkgId v = "Cabal-" ++ showVersion v
-
-compile :: FilePath -> Options -> Compile -> IO (Either ExitCode FilePath)
-compile distdir opts@Options {..} Compile {..} = do
-    cnCabalSourceDir
-        <- (canonicalizePath . cabalSourceDir) `traverse` compCabalSourceDir
-    appdir <- appCacheDir
-
-    let (outdir, exedir, exe, mchsrcdir) =
-          case cnCabalSourceDir of
-             Nothing  -> ( exeName compCabalVersion <.> "build"
-                         , appdir
-                         , appdir </> exeName compCabalVersion
-                         , Nothing
-                         )
-             Just _   -> ( distdir </> "cabal-helper"
-                         , distdir
-                         , distdir </> "cabal-helper" </> "cabal-helper"
-                         , Just $ distdir </> "cabal-helper"
-                         )
-
-    createDirectoryIfMissing True outdir
-    createDirectoryIfMissing True exedir
-
-    withHelperSources mchsrcdir $ \compCabalHelperSourceDir -> do
-
-    vLog opts $ "sourcedir: " ++ compCabalHelperSourceDir
-    vLog opts $ "outdir: " ++ outdir
-    vLog opts $ "exe: " ++ exe
-
-    let (mj1:mj2:mi:_) = case compCabalVersion of
-                         Left _commitid -> [10000000, 0, 0]
-                         Right (Version vs _) -> vs
-    let ghc_opts = concat [
-          [ "-outputdir", outdir
-          , "-o", exe
-          , "-optP-DCABAL_HELPER=1"
-          , "-optP-DCH_MIN_VERSION_Cabal(major1,major2,minor)=(\
-                   \   (major1)  < "++show mj1++" \
-                   \|| (major1) == "++show mj1++" && (major2)  < "++show mj2++"\
-                   \|| (major1) == "++show mj1++" && (major2) == "++show mj2++" && (minor) <= "++show mi++")"
-          ],
-          maybeToList $ ("-package-conf="++) <$> packageDbDir <$> compPackageDb,
-          map ("-i"++) $ nub $ "":compCabalHelperSourceDir:maybeToList cnCabalSourceDir,
-
-          if isNothing cnCabalSourceDir
-             then [ "-hide-all-packages"
-                  , "-package", "base"
-                  , "-package", "containers"
-                  , "-package", "directory"
-                  , "-package", "filepath"
-                  , "-package", "process"
-                  , "-package", "bytestring"
-                  , "-package", "ghc-prim"
-                  ]
-             else [],
-
-          concatMap (\p -> ["-package", p]) compPackageDeps,
-          [ "--make"
-          ,  compCabalHelperSourceDir</>"CabalHelper"</>"Runtime"</>"Main.hs"
-          ]
-         ]
-
-    rv <- callProcessStderr' opts Nothing ghcProgram ghc_opts
-    return $ case rv of
-               ExitSuccess -> Right exe
-               e@(ExitFailure _) -> Left e
-
-exeName :: Either String Version -> String
-exeName (Left commitid) = intercalate "-"
-    [ "cabal-helper" ++ showVersion version -- our ver
-    , "CabalHEAD" ++ commitid
-    ]
-exeName (Right compCabalVersion) = intercalate "-"
-    [ "cabal-helper" ++ showVersion version -- our ver
-    , "Cabal" ++ showVersion compCabalVersion
-    ]
-
-callProcessStderr'
-    :: Options -> Maybe FilePath -> FilePath -> [String] -> IO ExitCode
-callProcessStderr' opts mwd exe args = do
-  let cd = case mwd of
-             Nothing -> []; Just wd -> [ "cd", formatProcessArg wd++";" ]
-  vLog opts $ intercalate " " $ cd ++ map formatProcessArg (exe:args)
-  (_, _, _, h) <- createProcess (proc exe args) { std_out = UseHandle stderr
-                                                , cwd = mwd }
-  waitForProcess h
-
-callProcessStderr :: Options -> Maybe FilePath -> FilePath -> [String] -> IO ()
-callProcessStderr opts mwd exe args = do
-  rv <- callProcessStderr' opts mwd exe args
-  case rv of
-    ExitSuccess -> return ()
-    ExitFailure v -> processFailedException "callProcessStderr" exe args v
-
-processFailedException :: String -> String -> [String] -> Int -> IO a
-processFailedException fn exe args rv =
-    ioError $ mkIOError OtherError msg Nothing Nothing
-  where
-    msg = concat [ fn, ": ", exe, " "
-                 , intercalate " " (map formatProcessArg args)
-                 , " (exit " ++ show rv ++ ")"
-                 ]
-
-formatProcessArg :: String -> String
-formatProcessArg xs
-    | any isSpace xs = "'"++ xs ++"'"
-    | otherwise      = xs
-
-data HEAD = HEAD deriving (Eq, Show)
-
-installCabal :: Options -> Either HEAD Version -> IO (PackageDbDir, Either String Version)
-installCabal opts ever = do
-  appdir <- appCacheDir
-  let message ver = do
-      let sver = showVersion ver
-      hPutStr stderr $ printf "\
-\cabal-helper-wrapper: Installing a private copy of Cabal because we couldn't\n\
-\find the right version in your global/user package-db, this might take a\n\
-\while but will only happen once per Cabal version you're using.\n\
-\\n\
-\If anything goes horribly wrong just delete this directory and try again:\n\
-\    %s\n\
-\\n\
-\If you want to avoid this automatic installation altogether install\n\
-\version %s of Cabal manually (into your user or global package-db):\n\
-\    $ cabal install Cabal --constraint \"Cabal == %s\"\n\
-\\n\
-\Installing Cabal %s ...\n" appdir sver sver sver
-
-  withSystemTempDirectory "cabal-helper-Cabal-source" $ \tmpdir -> do
-    (srcdir, e_commit_ver) <- case ever of
-      Left HEAD -> do
-        second Left <$> unpackCabalHEAD tmpdir
-      Right ver -> do
-        message ver
-        let patch = fromMaybe nopCabalPatchDescription $
-              find ((ver`elem`) . cpdVersions) patchyCabalVersions
-        (,) <$> unpackPatchedCabal opts ver tmpdir patch <*> pure (Right ver)
-
-    db <- createPkgDb opts e_commit_ver
-
-    runCabalInstall opts db srcdir ever
-
-    return (db, e_commit_ver)
-
-{-
-TODO: If the Cabal version we want to install is less than or equal to one we
-have available, either through act-as-setup or in a package-db we should be able
-to use act-as-setup or build a default Setup.hs exe and patch the Cabal source
-to say build-type:simple. This will sidestep bugs in c-i>=1.24
-
-See conversation in
-https://github.com/haskell/cabal/commit/e2bf243300957321497353a2f85517e464f764ab
-
-Otherwise we might be able to use the shipped Setup.hs
-
--}
-
-runCabalInstall
-    :: Options -> PackageDbDir -> CabalSourceDir -> Either HEAD Version-> IO ()
-runCabalInstall opts (PackageDbDir db) (CabalSourceDir srcdir) ever = do
-  cabalInstallVer <- cabalInstallVersion opts
-  cabal_opts <- return $ concat
-      [
-        [ "--package-db=clear"
-        , "--package-db=global"
-        , "--package-db=" ++ db
-        , "--prefix=" ++ db </> "prefix"
-        ]
-        , cabalOptions opts
-        , if cabalInstallVer >= Version [1,20,0,0] []
-             then ["--no-require-sandbox"]
-             else []
-        , [ "install", srcdir ]
-        , if verbose opts
-            then ["-v"]
-            else []
-        , [ "--only-dependencies" ]
-      ]
-
-  callProcessStderr opts (Just "/") (cabalProgram opts) cabal_opts
-
-  setupProgram <- compileSetupHs opts db srcdir
-  runSetupHs opts setupProgram db srcdir ever
-
-  hPutStrLn stderr "done"
-
-cabalOptions :: Options -> [String]
-cabalOptions opts =
-    concat [ [ "--with-ghc=" ++ ghcProgram opts ]
-           , if ghcPkgProgram opts /= ghcPkgProgram defaultOptions
-               then [ "--with-ghc-pkg=" ++ ghcPkgProgram opts ]
-               else []
-           ]
-
-runSetupHs
-    :: Options
-    -> SetupProgram
-    -> FilePath
-    -> FilePath
-    -> Either HEAD Version
-    -> IO ()
-runSetupHs opts SetupProgram {..} db srcdir ever = do
-  let run = callProcessStderr opts (Just srcdir) setupProgram
-      parmake_opt
-          | Right ver <- ever,  ver >= Version [1,20] [] = ["-j"]
-          | otherwise = []
-
-  run $ [ "configure", "--package-db", db, "--prefix", db </> "prefix" ] ++ cabalOptions opts
-  run $ [ "build" ] ++ parmake_opt
-  run [ "copy" ]
-  run [ "register" ]
-
-newtype SetupProgram = SetupProgram { setupProgram :: FilePath }
-compileSetupHs :: Options -> FilePath -> FilePath -> IO SetupProgram
-compileSetupHs opts db srcdir = do
-  ver <- ghcVersion opts
-  let no_version_macros
-        | ver >= Version [8] [] = [ "-fno-version-macros" ]
-        | otherwise             = []
-
-      file = srcdir </> "Setup"
-
-  callProcessStderr opts (Just srcdir) (ghcProgram opts) $ concat
-    [ [ "--make"
-      , "-package-conf", db
-      ]
-    , no_version_macros
-    , [ file <.> "hs"
-      , "-o", file
-      ]
-    ]
-  return $ SetupProgram file
-
-data CabalPatchDescription = CabalPatchDescription {
-      cpdVersions      :: [Version],
-      cpdUnpackVariant :: UnpackCabalVariant,
-      cpdPatchFn       :: FilePath -> IO ()
-    }
-nopCabalPatchDescription :: CabalPatchDescription
-nopCabalPatchDescription = CabalPatchDescription [] LatestRevision (const (return ()))
-
-patchyCabalVersions :: [CabalPatchDescription]
-patchyCabalVersions = [
-  let versions  = [ Version [1,18,1] [] ]
-      variant   = Pristine
-      patch     = fixArrayConstraint
-  in CabalPatchDescription versions variant patch,
-
-  let versions  = [ Version [1,18,0] [] ]
-      variant   = Pristine
-      patch dir = do
-        fixArrayConstraint dir
-        fixOrphanInstance dir
-  in CabalPatchDescription versions variant patch,
-
-  let versions  = [ Version [1,24,1,0] [] ]
-      variant   = Pristine
-      patch _   = return ()
-  in CabalPatchDescription versions variant patch
-  ]
- where
-   fixArrayConstraint dir = do
-     let cabalFile    = dir </> "Cabal.cabal"
-         cabalFileTmp = cabalFile ++ ".tmp"
-
-     cf <- readFile cabalFile
-     writeFile cabalFileTmp $ replace "&& < 0.5" "&& < 0.6" cf
-     renameFile cabalFileTmp cabalFile
-
-   fixOrphanInstance dir = do
-     let versionFile    = dir </> "Distribution/Version.hs"
-         versionFileTmp = versionFile ++ ".tmp"
-
-     let languagePragma =
-           "{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}"
-         languagePragmaCPP =
-           "{-# LANGUAGE CPP, DeriveDataTypeable, StandaloneDeriving #-}"
-
-         derivingDataVersion =
-           "deriving instance Data Version"
-         derivingDataVersionCPP = unlines [
-             "#if __GLASGOW_HASKELL__ < 707",
-             derivingDataVersion,
-             "#endif"
-           ]
-
-     vf <- readFile versionFile
-     writeFile versionFileTmp
-       $ replace derivingDataVersion derivingDataVersionCPP
-       $ replace languagePragma languagePragmaCPP vf
-
-     renameFile versionFileTmp versionFile
-
-unpackPatchedCabal
-    :: Options
-    -> Version
-    -> FilePath
-    -> CabalPatchDescription
-    -> IO CabalSourceDir
-unpackPatchedCabal opts cabalVer tmpdir (CabalPatchDescription _ variant patch) = do
-  res@(CabalSourceDir dir) <- unpackCabal opts cabalVer tmpdir variant
-  patch dir
-  return res
-
-data UnpackCabalVariant = Pristine | LatestRevision
-newtype CabalSourceDir = CabalSourceDir { cabalSourceDir :: FilePath }
-unpackCabal
-    :: Options -> Version -> FilePath -> UnpackCabalVariant -> IO CabalSourceDir
-unpackCabal opts cabalVer tmpdir variant = do
-  let cabal = "Cabal-" ++ showVersion cabalVer
-      dir = tmpdir </> cabal
-      variant_opts = case variant of Pristine -> [ "--pristine" ]; _ -> []
-      args = [ "get", cabal ] ++ variant_opts
-  callProcessStderr opts (Just tmpdir) (cabalProgram opts) args
-  return $ CabalSourceDir dir
-
-unpackCabalHEAD :: FilePath -> IO (CabalSourceDir, String)
-unpackCabalHEAD tmpdir = do
-  let dir = tmpdir </> "cabal-head.git"
-      url = "https://github.com/haskell/cabal.git"
-  ExitSuccess <- rawSystem "git" [ "clone", "--depth=1", url, dir]
-  commit <-
-      withDirectory_ dir $ trim <$> readProcess "git" ["rev-parse", "HEAD"] ""
-  return (CabalSourceDir $ dir </> "Cabal", commit)
- where
-   withDirectory_ :: FilePath -> IO a -> IO a
-   withDirectory_ dir action =
-       bracket
-         (liftIO getCurrentDirectory)
-         (liftIO . setCurrentDirectory)
-         (\_ -> liftIO (setCurrentDirectory dir) >> action)
-
-errorInstallCabal :: Version -> FilePath -> IO a
-errorInstallCabal cabalVer _distdir = panicIO $ printf "\
-\Installing Cabal version %s failed.\n\
-\\n\
-\You have the following choices to fix this:\n\
-\\n\
-\- The easiest way to try and fix this is just reconfigure the project and try\n\
-\  again:\n\
-\        $ cabal clean && cabal configure\n\
-\\n\
-\- If that fails you can try to install the version of Cabal mentioned above\n\
-\  into your global/user package-db somehow, you'll probably have to fix\n\
-\  something otherwise it wouldn't have failed above:\n\
-\        $ cabal install Cabal --constraint 'Cabal == %s'\n\
-\\n\
-\- If you're using `Build-Type: Simple`:\n\
-\  - You can see if you can reinstall your cabal-install executable while\n\
-\    having it linked to a version of Cabal that's available in you\n\
-\    package-dbs or can be built automatically:\n\
-\        $ ghc-pkg list | grep Cabal  # find an available Cabal version\n\
-\            Cabal-W.X.Y.Z\n\
-\        $ cabal install cabal-install --constraint 'Cabal == W.X.*'\n\
-\    Afterwards you'll have to reconfigure your project:\n\
-\        $ cabal clean && cabal configure\n\
-\\n\
-\- If you're using `Build-Type: Custom`:\n\
-\  - Have cabal-install rebuild your Setup.hs executable with a version of the\n\
-\    Cabal library that you have available in your global/user package-db:\n\
-\        $ cabal clean && cabal configure\n\
-\    You might also have to install some version of the Cabal to do this:\n\
-\        $ cabal install Cabal\n\
-\\n" sver sver
- where
-   sver = showVersion cabalVer
-
-cachedExe :: Version -> IO (Maybe FilePath)
-cachedExe compCabalVersion = do
-    appdir <- appCacheDir
-    let exe = appdir </> exeName (Right compCabalVersion)
-    exists <- doesFileExist exe
-    return $ if exists then Just exe else Nothing
-
-listCabalVersions :: Options -> IO [Version]
-listCabalVersions opts = listCabalVersions' opts Nothing
-
--- TODO: Include sandbox? Probably only relevant for build-type:custom projects.
-listCabalVersions' :: Options -> Maybe PackageDbDir -> IO [Version]
-listCabalVersions' Options {..} mdb = do
-  let mdbopt = ("--package-conf="++) <$> packageDbDir <$> mdb
-      opts = ["list", "--simple-output", "Cabal"] ++ maybeToList mdbopt
-
-  catMaybes . map (fmap snd . parsePkgId . fromString) . words
-          <$> readProcess ghcPkgProgram opts ""
-
-cabalVersionExistsInPkgDb :: Options -> Version -> IO Bool
-cabalVersionExistsInPkgDb opts cabalVer = do
-  db@(PackageDbDir db_path) <- getPrivateCabalPkgDb opts (Right cabalVer)
-  exists <- doesDirectoryExist db_path
-  case exists of
-    False -> return False
-    True -> do
-      vers <- listCabalVersions' opts (Just db)
-      return $ cabalVer `elem` vers
-
-
-ghcVersion :: Options -> IO Version
-ghcVersion Options {..} = do
-    parseVer . trim <$> readProcess ghcProgram ["--numeric-version"] ""
-
-ghcPkgVersion :: Options -> IO Version
-ghcPkgVersion Options {..} = do
-    parseVer . trim . dropWhile (not . isDigit) <$> readProcess ghcPkgProgram ["--version"] ""
-
-cabalInstallVersion :: Options -> IO Version
-cabalInstallVersion Options {..} = do
-    parseVer . trim <$> readProcess cabalProgram ["--numeric-version"] ""
-
-trim :: String -> String
-trim = dropWhileEnd isSpace
-
-createPkgDb :: Options -> Either String Version -> IO PackageDbDir
-createPkgDb opts@Options {..} cabalVer = do
-  db@(PackageDbDir db_path) <- getPrivateCabalPkgDb opts cabalVer
-  exists <- doesDirectoryExist db_path
-  when (not exists) $ callProcessStderr opts Nothing ghcPkgProgram ["init", db_path]
-  return db
-
-getPrivateCabalPkgDb :: Options -> Either String Version -> IO PackageDbDir
-getPrivateCabalPkgDb opts cabalVer = do
-  appdir <- appCacheDir
-  ghcVer <- ghcVersion opts
-  let db_path = appdir </> exeName cabalVer
-                ++ "-ghc" ++ showVersion ghcVer
-                ++ ".package-db"
-  return $ PackageDbDir db_path
-
--- "Cabal" ++ ver ++ "-ghc" ++ showVersion ghcVer
-
--- | Find @version: XXX@ delcaration in a cabal file
-cabalFileVersion :: String -> Version
-cabalFileVersion cabalFile =
-  fromJust $ parseVer . extract <$> find ("version:" `isPrefixOf`) ls
- where
-  ls = map (map toLower) $ lines cabalFile
-  extract = dropWhile (/=':') >>> drop 1 >>> dropWhile isSpace >>> takeWhile (not . isSpace)
diff --git a/CabalHelper/Compiletime/Data.hs b/CabalHelper/Compiletime/Data.hs
deleted file mode 100644
index 2842cfc..0000000
--- a/CabalHelper/Compiletime/Data.hs
+++ /dev/null
@@ -1,86 +0,0 @@
--- Copyright (C) 2015,2017  Daniel Gröber <dxld ÄT darkboxed DOT org>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU Affero General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Affero General Public License for more details.
---
--- You should have received a copy of the GNU Affero General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE TemplateHaskell, ScopedTypeVariables #-}
-{-# OPTIONS_GHC -fforce-recomp #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Data
-Description : Embeds source code for runtime component using TH
-License     : AGPL-3
--}
-
-module CabalHelper.Compiletime.Data where
-
-import Control.Monad
-import Control.Monad.IO.Class
-import Data.Functor
-import qualified Data.ByteString as BS
-import qualified Data.ByteString.UTF8 as UTF8
-import Language.Haskell.TH
-import System.Directory
-import System.FilePath
-import System.IO.Temp
-import System.Posix.Files
-import System.Posix.Time
-import System.Posix.Types
-import Prelude
-
-import CabalHelper.Compiletime.Compat.Environment
-
-withSystemTempDirectoryEnv :: String -> (FilePath -> IO b) -> IO b
-withSystemTempDirectoryEnv tpl f = do
-  m <- liftIO $ lookupEnv "CABAL_HELPER_KEEP_SOURCEDIR"
-  case m of
-    Nothing -> withSystemTempDirectory tpl f
-    Just _  -> do
-           tmpdir <- getCanonicalTemporaryDirectory
-           f =<< createTempDirectory tmpdir tpl
-
-withHelperSources :: Maybe FilePath -> (FilePath -> IO a) -> IO a
-withHelperSources mdir action = withDir mdir $ \dir -> do
-    let chdir = dir </> "CabalHelper"
-    liftIO $ do
-      createDirectoryIfMissing True $ chdir </> "Runtime"
-      createDirectoryIfMissing True $ chdir </> "Shared"
-
-    let modtime :: EpochTime
-        modtime = fromIntegral $ (read :: String -> Integer)
-          -- See https://reproducible-builds.org/specs/source-date-epoch/
-          $(runIO $ do
-             msde :: Maybe Integer
-                  <- fmap read <$> lookupEnv "SOURCE_DATE_EPOCH"
-             (current_time :: Integer) <- round . toRational <$> epochTime
-             return $ LitE . StringL $ show $ maybe current_time id msde)
-
-    liftIO $ forM_ sourceFiles $ \(fn, src) -> do
-        let path = chdir </> fn
-        BS.writeFile path $ UTF8.fromString src
-        setFileTimes path modtime modtime
-
-    action dir
-  where
-    withDir (Just dir) = \f -> f dir
-    withDir Nothing    = withSystemTempDirectoryEnv "cabal-helper-source"
-
-
-sourceFiles :: [(FilePath, String)]
-sourceFiles =
-  [ ("Runtime/Main.hs",     $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "CabalHelper/Runtime/Main.hs")))
-  , ("Runtime/Licenses.hs", $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "CabalHelper/Runtime/Licenses.hs")))
-  , ("Shared/Common.hs",    $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "CabalHelper/Shared/Common.hs")))
-  , ("Shared/Sandbox.hs",   $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "CabalHelper/Shared/Sandbox.hs")))
-  , ("Shared/InterfaceTypes.hs",     $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "CabalHelper/Shared/InterfaceTypes.hs")))
-  ]
diff --git a/CabalHelper/Compiletime/GuessGhc.hs b/CabalHelper/Compiletime/GuessGhc.hs
deleted file mode 100644
index f4b33d5..0000000
--- a/CabalHelper/Compiletime/GuessGhc.hs
+++ /dev/null
@@ -1,92 +0,0 @@
--- Copyright (c) 2003-2014, Isaac Jones, Simon Marlow, Martin Sjögren,
---                          Bjorn Bringert, Krasimir Angelov,
---                          Malcolm Wallace, Ross Patterson, Ian Lynagh,
---                          Duncan Coutts, Thomas Schilling,
---                          Johan Tibell, Mikhail Glushenkov
--- All rights reserved.
-
--- Redistribution and use in source and binary forms, with or without
--- modification, are permitted provided that the following conditions are
--- met:
-
---     * Redistributions of source code must retain the above copyright
---       notice, this list of conditions and the following disclaimer.
-
---     * Redistributions in binary form must reproduce the above
---       copyright notice, this list of conditions and the following
---       disclaimer in the documentation and/or other materials provided
---       with the distribution.
-
---     * Neither the name of Isaac Jones nor the names of other
---       contributors may be used to endorse or promote products derived
---       from this software without specific prior written permission.
-
--- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
--- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
--- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
--- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
--- OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
--- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
--- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
--- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
--- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
--- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
--- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-{-|
-Module      : CabalHelper.Compiletime.GuessGhc
-Description : Logic for finding @ghc-pkg@ based on path to @ghc@
-License     : BSD3
--}
-
-module CabalHelper.Compiletime.GuessGhc (guessToolFromGhcPath) where
-
-import Data.Maybe
-import Data.Char
-import Distribution.Simple.BuildPaths
-import System.Directory
-import System.FilePath
-
-guessToolFromGhcPath :: FilePath -- ^ Tool name
-                     -> FilePath -- ^ GHC exe path
-                     -> IO (Maybe FilePath)
-guessToolFromGhcPath toolname ghcPath
-  = do let
-           path              = ghcPath
-           dir               = takeDirectory path
-           versionSuffix     = takeVersionSuffix (dropExeExtension path)
-           guessNormal       = dir </> toolname <.> exeExtension'
-           guessGhcVersioned = dir </> (toolname ++ "-ghc" ++ versionSuffix)
-                               <.> exeExtension'
-           guessVersioned    = dir </> (toolname ++ versionSuffix)
-                               <.> exeExtension'
-           guesses | null versionSuffix = [guessNormal]
-                   | otherwise          = [guessGhcVersioned,
-                                           guessVersioned,
-                                           guessNormal]
-       exists <- mapM doesFileExist guesses
-       return $ listToMaybe [ file | (file, True) <- zip guesses exists ]
-
-  where takeVersionSuffix :: FilePath -> String
-        takeVersionSuffix = takeWhileEndLE isSuffixChar
-
-        isSuffixChar :: Char -> Bool
-        isSuffixChar c = isDigit c || c == '.' || c == '-'
-
-        dropExeExtension :: FilePath -> FilePath
-        dropExeExtension filepath =
-          case splitExtension filepath of
-            (filepath', extension) | extension == exeExtension' -> filepath'
-                                   | otherwise                 -> filepath
-
--- | @takeWhileEndLE p@ is equivalent to @reverse . takeWhile p . reverse@, but
--- is usually faster (as well as being easier to read).
-takeWhileEndLE :: (a -> Bool) -> [a] -> [a]
-takeWhileEndLE p = fst . foldr go ([], False)
-  where
-    go x (rest, done)
-      | not done && p x = (x:rest, False)
-      | otherwise = (rest, True)
-
-exeExtension' :: FilePath
-exeExtension' = Distribution.Simple.BuildPaths.exeExtension
diff --git a/CabalHelper/Compiletime/Log.hs b/CabalHelper/Compiletime/Log.hs
deleted file mode 100644
index a75f8b7..0000000
--- a/CabalHelper/Compiletime/Log.hs
+++ /dev/null
@@ -1,44 +0,0 @@
--- Copyright (C) 2017  Daniel Gröber <dxld ÄT darkboxed DOT org>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU Affero General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Affero General Public License for more details.
---
--- You should have received a copy of the GNU Affero General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE ScopedTypeVariables #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Log
-Description : Basic logging facilities
-License     : AGPL-3
--}
-
-module CabalHelper.Compiletime.Log where
-
-import Control.Monad
-import Control.Monad.IO.Class
-import Control.Exception as E
-import Data.String
-import System.IO
-import Prelude
-
-import CabalHelper.Compiletime.Types
-
-vLog :: MonadIO m => Options -> String -> m ()
-vLog Options { verbose = True } msg =
-    liftIO $ hPutStrLn stderr msg
-vLog _ _ = return ()
-
-logIOError :: Options -> String -> IO (Maybe a) -> IO (Maybe a)
-logIOError opts label a = do
-  a `E.catch` \(ex :: IOError) -> do
-      vLog opts $ label ++ ": " ++ show ex
-      return Nothing
diff --git a/CabalHelper/Compiletime/Types.hs b/CabalHelper/Compiletime/Types.hs
deleted file mode 100644
index bfe9b7c..0000000
--- a/CabalHelper/Compiletime/Types.hs
+++ /dev/null
@@ -1,40 +0,0 @@
--- Copyright (C) 2015  Daniel Gröber <dxld ÄT darkboxed DOT org>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU Affero General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Affero General Public License for more details.
---
--- You should have received a copy of the GNU Affero General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE DeriveGeneric, DeriveDataTypeable, DefaultSignatures #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Types
-Description : Types used throughout
-License     : AGPL-3
--}
-
-module CabalHelper.Compiletime.Types where
-
-import Data.Version
-
-data Options = Options {
-          verbose       :: Bool
-        , ghcProgram    :: FilePath
-        , ghcPkgProgram :: FilePath
-        , cabalProgram  :: FilePath
-        , cabalVersion  :: Maybe Version
-        , cabalPkgDb    :: Maybe PackageDbDir
-}
-
-newtype PackageDbDir = PackageDbDir { packageDbDir :: FilePath }
-
-defaultOptions :: Options
-defaultOptions = Options False "ghc" "ghc-pkg" "cabal" Nothing Nothing
diff --git a/CabalHelper/Compiletime/Wrapper.hs b/CabalHelper/Compiletime/Wrapper.hs
deleted file mode 100644
index 6713944..0000000
--- a/CabalHelper/Compiletime/Wrapper.hs
+++ /dev/null
@@ -1,164 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015  Daniel Gröber <dxld ÄT darkboxed DOT org>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU Affero General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU Affero General Public License for more details.
---
--- You should have received a copy of the GNU Affero General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-{-# LANGUAGE RecordWildCards, FlexibleContexts #-}
-module Main where
-
-import Control.Applicative
-import Control.Monad
-import Data.Char
-import Data.List
-import Data.Maybe
-import Data.String
-import Text.Printf
-import System.Console.GetOpt
-import System.Environment
-import System.Directory
-import System.FilePath
-import System.Process
-import System.Exit
-import System.IO
-import Prelude
-
-import Distribution.System (buildPlatform)
-import Distribution.Text (display)
-import Distribution.Verbosity (silent, deafening)
-import Distribution.PackageDescription.Parse (readPackageDescription)
-import Distribution.Package (packageName, packageVersion)
-
-import Paths_cabal_helper (version)
-import CabalHelper.Compiletime.Compat.Version
-import CabalHelper.Compiletime.Compile
-import CabalHelper.Compiletime.GuessGhc
-import CabalHelper.Compiletime.Types
-import CabalHelper.Shared.Common
-import CabalHelper.Shared.InterfaceTypes
-
-usage :: IO ()
-usage = do
-  prog <- getProgName
-  hPutStr stderr $ "Usage: " ++ prog ++ " " ++ usageMsg
- where
-   usageMsg = "\
-\( print-appcachedir\n\
-\| print-build-platform\n\
-\| [--verbose]\n\
-\  [--with-ghc=GHC_PATH]\n\
-\  [--with-ghc-pkg=GHC_PKG_PATH]\n\
-\  [--with-cabal=CABAL_PATH]\n\
-\  [--with-cabal-version=VERSION]\n\
-\  [--with-cabal-pkg-db=PKG_DB]\n\
-\  PROJ_DIR DIST_DIR ( print-exe | package-id | [CABAL_HELPER_ARGS...] ) )\n"
-
-globalArgSpec :: [OptDescr (Options -> Options)]
-globalArgSpec =
-      [ option "" ["verbose"] "Be more verbose" $
-              NoArg $ \o -> o { verbose = True }
-
-      , option "" ["with-ghc"] "GHC executable to use" $
-              reqArg "PROG" $ \p o -> o { ghcProgram = p }
-
-      , option "" ["with-ghc-pkg"] "ghc-pkg executable to use (only needed when guessing from GHC path fails)" $
-              reqArg "PROG" $ \p o -> o { ghcPkgProgram = p }
-
-      , option "" ["with-cabal"] "cabal-install executable to use" $
-               reqArg "PROG" $ \p o -> o { cabalProgram = p }
-
-      , option "" ["with-cabal-version"] "Cabal library version to use" $
-               reqArg "VERSION" $ \p o -> o { cabalVersion = Just $ parseVer p }
-
-      , option "" ["with-cabal-pkg-db"] "package database to look for Cabal library in" $
-               reqArg "PKG_DB" $ \p o -> o { cabalPkgDb = Just (PackageDbDir p) }
-
-      ]
- where
-   option :: [Char] -> [String] -> String -> ArgDescr a -> OptDescr a
-   option s l udsc dsc = Option s l dsc udsc
-
-   reqArg :: String -> (String -> a) -> ArgDescr a
-   reqArg udsc dsc = ReqArg dsc udsc
-
-parseCommandArgs :: Options -> [String] -> (Options, [String])
-parseCommandArgs opts argv
-    = case getOpt RequireOrder globalArgSpec argv of
-        (o,r,[])   -> (foldr id opts o, r)
-        (_,_,errs) ->
-            panic $ "Parsing command options failed:\n" ++ concat errs
-
-guessProgramPaths :: Options -> IO Options
-guessProgramPaths opts = do
-    if not (same ghcProgram opts dopts) && same ghcPkgProgram opts dopts
-       then do
-         mghcPkg <- guessToolFromGhcPath "ghc-pkg" (ghcProgram opts)
-         return opts {
-           ghcPkgProgram = fromMaybe (ghcPkgProgram opts) mghcPkg
-         }
-       else return opts
- where
-   same f o o'  = f o == f o'
-   dopts = defaultOptions
-
-overrideVerbosityEnvVar :: Options -> IO Options
-overrideVerbosityEnvVar opts = do
-  x <- lookup  "CABAL_HELPER_DEBUG" <$> getEnvironment
-  return $ case x of
-    Just _  -> opts { verbose = True }
-    Nothing -> opts
-
-main :: IO ()
-main = handlePanic $ do
-  (opts', args) <- parseCommandArgs defaultOptions <$> getArgs
-  opts <- overrideVerbosityEnvVar =<< guessProgramPaths opts'
-  case args of
-    [] -> usage
-    "help":[] -> usage
-    "version":[] -> putStrLn $ showVersion version
-    "print-appdatadir":[] -> putStrLn =<< appCacheDir
-    "print-appcachedir":[] -> putStrLn =<< appCacheDir
-    "print-build-platform":[] -> putStrLn $ display buildPlatform
-
-    projdir:_distdir:"package-id":[] -> do
-      let v | verbose opts = deafening
-            | otherwise    = silent
-      -- ghc-mod will catch multiple cabal files existing before we get here
-      [cfile] <- filter isCabalFile <$> getDirectoryContents projdir
-      gpd <- readPackageDescription v (projdir </> cfile)
-      putStrLn $ show $
-        [Just $ ChResponseVersion (display (packageName gpd)) (toDataVersion $ packageVersion gpd)]
-
-    projdir:distdir:args' -> do
-      cfgf <- canonicalizePath (distdir </> "setup-config")
-      mhdr <- getCabalConfigHeader cfgf
-      case mhdr of
-        Nothing -> panic $ printf "\
-\Could not read Cabal's persistent setup configuration header\n\
-\- Check first line of: %s\n\
-\- Maybe try: $ cabal configure" cfgf
-        Just (hdrCabalVersion, _) -> do
-          case cabalVersion opts of
-            Just ver | hdrCabalVersion /= ver -> panic $ printf "\
-\Cabal version %s was requested but setup configuration was\n\
-\written by version %s" (showVersion ver) (showVersion hdrCabalVersion)
-            _ -> do
-              eexe <- compileHelper opts hdrCabalVersion projdir distdir
-              case eexe of
-                  Left e -> exitWith e
-                  Right exe ->
-                    case args' of
-                      "print-exe":_ -> putStrLn exe
-                      _ -> do
-                        (_,_,_,h) <- createProcess $ proc exe args
-                        exitWith =<< waitForProcess h
-    _ -> error "invalid command line"