{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE NoImplicitPrelude #-}
-- | A general purpose build tool.
--
-- : out bild
--
-- == Design constraints
--
-- * only input is one or more a namespaces. no subcommands, no packages
--
-- * no need to write specific build rules, one rule for hs, one for rs, one
-- for scm, and so on
--
-- * no need to distinguish between exe and lib, just have a single output,
-- or figure it out automatically
--
-- * never concerned with deployment/packaging - leave that to another tool
-- (scp? tar?)
--
-- == Features
--
-- * namespace maps to filesystem
--
-- * no need for `bild -l` for listing available targets.
-- Use `ls` or `tree`
--
-- * you build namespaces, not files/modules/packages/etc
--
-- * namespace maps to language modules
--
-- * build settings can be set in the file comments
--
-- * pwd is always considered the the source directory,
-- no `src` vs `doc` etc.
--
-- * build methods automaticatly detected with file extensions
--
-- * flags modify the way to interact with the build, some ideas:
--
-- * -s = jump into a shell and/or repl
--
-- * -p = turn on profiling
--
-- * -t = limit build by type (file extension)
--
-- * -e = exclude some regex in the ns tree
--
-- * -o = optimize level
--
-- == Example Commands
--
-- > bild [opts] <target..>
--
-- The general scheme is to build the things described by the targets. A target
-- is a namespace. You can list as many as you want, but you must list at least
-- one. It could just be `.` for the current directory. Build outputs will go
-- into the _/bild directory in the root of the project.
--
-- > bild A/B.hs
--
-- This will build the file at ./A/B.hs, which translates to something like
-- `ghc --make A.B`.
--
-- > bild -s <target>
--
-- Starts a repl/shell for target.
--
-- - if target.hs, load ghci
-- - if target.scm, load scheme repl
-- - if target.clj, load a clojure repl
-- - if target.nix, load nix-shell
-- - and so on.
--
-- > bild -p <target>
--
-- build target with profiling (if available)
--
-- > bild -t nix target
--
-- only build target.nix, not target.hs and so on (in the case of multiple
-- targets with the same name but different extension).
--
-- == Build Metadata
--
-- Metadata is set in the comments with a special syntax. For system-level deps,
-- we list the deps in comments in the target file, like:
--
-- > -- : sys cmark
--
-- The name is used to lookup the package in `nixpkgs.pkgs.<name>`.
-- Language-level deps can automatically determined by passing parsed import
-- statements to a package database, eg `ghc-pkg find-module`.
--
-- The output executable is named with:
--
-- > -- : out my-program
--
-- or
--
-- > -- : out my-ap.js
--
-- When multiple compilers are possible (e.g. ghc vs ghcjs) we use the @out@
-- extension, for example we chose ghcjs when the target @out@ ends in .js. If
-- @out@ does not have an extension, each build type falls back to a default,
-- usually an executable binary.
--
-- This method of setting metadata in the module comments works pretty well,
-- and really only needs to be done in the entrypoint module anyway.
--
-- Local module deps are included by just giving the repo root to the underlying
-- compiler for the target, and the compiler does work of walking the source
-- tree.
module Biz.Bild where
import Alpha hiding (sym, (<.>))
import qualified Biz.Cli as Cli
import qualified Biz.Log as Log
import Biz.Namespace (Namespace (..))
import qualified Biz.Namespace as Namespace
import qualified Biz.Test as Test
import qualified Control.Concurrent.Async as Async
import qualified Data.Aeson as Aeson
import qualified Data.ByteString.Char8 as Char8
import qualified Data.ByteString.Lazy as ByteString
import qualified Data.Char as Char
import Data.Conduit ((.|))
import qualified Data.Conduit as Conduit
import qualified Data.Conduit.List as Conduit
import qualified Data.Conduit.Process as Conduit
import qualified Data.List as List
import qualified Data.Map as Map
import qualified Data.Maybe as Maybe
import qualified Data.Set as Set
import qualified Data.String as String
import qualified Data.Text as Text
import qualified Data.Text.IO as Text.IO
import qualified System.Directory as Dir
import qualified System.Environment as Env
import qualified System.Exit as Exit
import System.FilePath (replaceExtension, (</>))
import qualified System.IO as IO
import qualified System.Process as Process
import qualified Text.Regex.Applicative as Regex
main :: IO ()
main = Cli.main <| Cli.Plan help move test pure
where
test =
Test.group
"Biz.Bild"
[ Test.unit "can bild bild" <| do
analyze "Biz/Bild.hs" /> Maybe.fromJust +> build False False +> \case
Exit.ExitFailure _ -> Test.assertFailure "can't bild bild"
_ -> pure ()
]
move :: Cli.Arguments -> IO ()
move args =
IO.hSetBuffering stdout IO.NoBuffering
>> pure (Cli.getAllArgs args (Cli.argument "target"))
/> filter (not <. ("_" `List.isPrefixOf`))
+> filterM Dir.doesFileExist
+> traverse (\fn -> analyze fn /> (fn,))
/> filter (snd .> isJust)
/> Map.fromList
/> Map.map Maybe.fromJust
/> Map.filter (namespace .> isBuildableNs)
+> printOrBuild
+> exitSummary
where
printOrBuild :: Map FilePath Target -> IO [ExitCode]
printOrBuild analyses =
if args `Cli.has` Cli.longOption "analyze"
then Map.elems analyses |> putJSON >> pure [Exit.ExitSuccess]
else Map.toList analyses |> map snd |> traverse (build isTest isLoud)
isTest = args `Cli.has` Cli.longOption "test"
isLoud = args `Cli.has` Cli.longOption "loud"
putJSON = Aeson.encode .> ByteString.toStrict .> Char8.putStrLn
nixStore :: String
nixStore = "/nix/store/00000000000000000000000000000000-"
help :: Cli.Docopt
help =
[Cli.docopt|
bild
Usage:
bild test
bild [options] <target>...
Options:
--test Run tests on a target after building
--loud Show all output from compiler
--analyze Only analyze and print as JSON, don't build
-h, --help Print this info
|]
exitSummary :: [Exit.ExitCode] -> IO ()
exitSummary exits =
if failures > 0
then Exit.die <| show failures
else Exit.exitSuccess
where
failures = length <| filter isFailure exits
type Dep = String
type Out = String
data Compiler
= GhcLib
| GhcExe
| GhcjsLib
| GhcjsExe
| Guile
| NixBuild
| Copy
deriving (Show, Generic, Aeson.ToJSON)
data Target = Target
{ -- | Output name
out :: Maybe Out,
-- | Fully qualified namespace partitioned by '.'
namespace :: Namespace,
-- | Absolute path to file
path :: FilePath,
-- | Language-specific dependencies
langdeps :: Set Dep,
-- | System-level dependencies
sysdeps :: Set Dep,
-- | Which compiler should we use?
compiler :: Compiler,
-- | Where is this machine being built? Schema: user@location
builder :: Text
}
deriving (Show, Generic, Aeson.ToJSON)
-- | We can't build everything yet...
isBuildableNs :: Namespace -> Bool
isBuildableNs (Namespace (x : _) Namespace.Hs) | x /= "Hero" = True
isBuildableNs (Namespace _ Namespace.Scm) = True
isBuildableNs ns
| ns `elem` nixTargets = True
| otherwise = False
where
nixTargets =
[ Namespace ["Biz", "Pie"] Namespace.Nix,
Namespace ["Biz", "Que"] Namespace.Nix,
Namespace ["Biz", "Cloud"] Namespace.Nix,
Namespace ["Biz", "Dev"] Namespace.Nix
]
-- | Emulate the *nix hierarchy in the cabdir.
bindir, intdir, nixdir, vardir :: String
bindir = "_/bin"
intdir = "_/int"
nixdir = "_/nix"
vardir = "_/var"
createHier :: String -> IO ()
createHier root =
traverse_
(Dir.createDirectoryIfMissing True)
[ root </> bindir,
root </> intdir,
root </> nixdir,
root </> vardir
]
-- >>> removeVersion "array-0.5.4.0-DFLKGIjfsadi"
-- "array"
removeVersion :: String -> String
removeVersion = takeWhile (/= '.') .> butlast2
where
butlast2 s = take (length s - 2) s
detectImports :: Namespace -> [Text] -> IO (Set Dep)
detectImports (Namespace _ Namespace.Hs) contentLines = do
let imports =
contentLines
/> Text.unpack
/> Regex.match haskellImports
|> catMaybes
pkgs <- foldM ghcPkgFindModule Set.empty imports
transitivePkgs <-
imports
|> map (Namespace.fromHaskellModule .> Namespace.toPath)
|> traverse Dir.makeAbsolute
+> filterM Dir.doesFileExist
+> traverse analyze -- surely this is a bottleneck ripe for caching
/> catMaybes
/> map langdeps
/> mconcat
pure <| pkgs <> transitivePkgs
detectImports _ _ = Exit.die "can only detectImports for Haskell"
analyze :: FilePath -> IO (Maybe Target)
analyze path = do
content <-
withFile path ReadMode <| \h ->
IO.hSetEncoding h IO.utf8_bom
>> Text.IO.hGetContents h
let contentLines = Text.lines content
root <- Env.getEnv "BIZ_ROOT"
absPath <- Dir.makeAbsolute path
Log.info ["bild", "analyze", str path]
let ns =
if "hs" `List.isSuffixOf` path
then Namespace.fromContent <| Text.unpack content
else Namespace.fromPath root absPath
case ns of
Nothing ->
Log.warn ["bild", "analyze", str path, "could not find namespace"]
>> Log.br
>> pure Nothing
Just namespace@(Namespace _ ext) ->
Just </ do
user <- Env.getEnv "USER" /> Text.pack
host <- Text.pack </ fromMaybe "interactive" </ Env.lookupEnv "HOSTNAME"
case ext of
Namespace.Hs -> do
langdeps <- detectImports namespace contentLines
let out =
contentLines
/> Text.unpack
/> Regex.match (metaOut "--")
|> catMaybes
|> head
pure
Target
{ builder = user <> "@localhost",
compiler = detectGhcCompiler out <| Text.unpack content,
sysdeps =
contentLines
/> Text.unpack
/> Regex.match (metaSys "--")
|> catMaybes
|> Set.fromList,
..
}
Namespace.Nix ->
pure
Target
{ langdeps = Set.empty,
sysdeps = Set.empty,
compiler = NixBuild,
out = Nothing,
builder =
if host == "lithium"
then mempty
else
Text.concat
[ "ssh://",
user,
"@dev.simatime.com?ssh-key=/home/",
user,
"/.ssh/id_rsa"
],
..
}
Namespace.Scm -> do
pure
Target
{ langdeps = Set.empty,
sysdeps = Set.empty,
compiler = Guile,
out =
contentLines
/> Text.unpack
/> Regex.match (metaOut ";;")
|> catMaybes
|> head,
builder = user <> "@localhost",
..
}
_ ->
pure
Target
{ langdeps = Set.empty,
sysdeps = Set.empty,
compiler = Copy,
out = Nothing,
builder = user <> "@localhost",
..
}
ghcPkgFindModule :: Set String -> String -> IO (Set String)
ghcPkgFindModule acc m =
Process.readProcess
"ghc-pkg"
-- instead of relying on global deps declared in ./Bild/Deps/Haskell.nix, I
-- could fetch a global package-db from hackage API and pass it here with
-- --package-db=FILE
["--names-only", "--simple-output", "find-module", m]
""
/> String.lines
/> Set.fromList
/> Set.union acc
-- | Some rules for detecting the how to compile a ghc module. If there is an
-- out, then we know it's some Exe; if the out ends in .js then it's GhcjsExe,
-- otherwise GhcExe. That part is solved.
--
-- Detecting a Lib is harder, and much code can be compiled by both ghc and
-- ghcjs. For now I'm just guarding against known ghcjs-only modules in the
-- import list.
detectGhcCompiler :: Maybe Out -> String -> Compiler
detectGhcCompiler (Just out) _ | jsSuffix out = GhcjsExe
detectGhcCompiler (Just _) _ = GhcExe
detectGhcCompiler Nothing content
| match "import GHCJS" = GhcjsLib
| otherwise = GhcLib
where
match s = s `List.isInfixOf` content
jsSuffix :: String -> Bool
jsSuffix = List.isSuffixOf ".js"
isFailure :: Exit.ExitCode -> Bool
isFailure (Exit.ExitFailure _) = True
isFailure Exit.ExitSuccess = False
isSuccess :: Exit.ExitCode -> Bool
isSuccess Exit.ExitSuccess = True
isSuccess _ = False
build :: Bool -> Bool -> Target -> IO Exit.ExitCode
build andTest loud Target {..} = do
root <- Env.getEnv "BIZ_ROOT"
createHier root
case compiler of
GhcExe -> do
Log.info ["bild", "dev", "ghc-exe", nschunk namespace]
exitcode <-
proc
loud
namespace
"ghc"
[ "-Werror",
"-i" <> root,
"-odir",
root </> intdir,
"-hidir",
root </> intdir,
"--make",
path,
"-main-is",
Namespace.toHaskellModule namespace,
"-o",
root </> bindir </> Maybe.fromJust out
]
if andTest && isSuccess exitcode
then
run
<| Proc
{ loud = loud,
cmd = root </> bindir </> Maybe.fromJust out,
args = ["test"],
ns = namespace,
onFailure = Log.fail ["test", nschunk namespace] >> Log.br,
onSuccess = Log.pass ["test", nschunk namespace] >> Log.br
}
else pure exitcode
GhcLib -> do
Log.info ["bild", "dev", "ghc-lib", nschunk namespace]
proc
loud
namespace
"ghc"
[ "-Werror",
"-i" <> root,
"-odir",
root </> intdir,
"-hidir",
root </> intdir,
"--make",
path
]
GhcjsExe -> do
Log.info ["bild", "dev", "ghcjs-exe", nschunk namespace]
pure Exit.ExitSuccess
--proc
-- loud
-- namespace
-- "ghcjs"
-- [ "-Werror",
-- "-i" <> root,
-- "-odir",
-- root </> intdir,
-- "-hidir",
-- root </> intdir,
-- "--make",
-- path,
-- "-main-is",
-- Namespace.toHaskellModule namespace,
-- "-o",
-- root </> vardir </> Maybe.fromJust out
-- ]
GhcjsLib -> do
Log.info ["bild", "dev", "ghcjs-lib", nschunk namespace]
pure Exit.ExitSuccess
--proc
-- loud
-- namespace
-- "ghcjs"
-- [ "-Werror",
-- "-i" <> root,
-- "-odir",
-- root </> intdir,
-- "-hidir",
-- root </> intdir,
-- "--make",
-- path
-- ]
Guile -> do
Log.info ["bild", "dev", "guile", nschunk namespace]
_ <-
proc
loud
namespace
"guild"
[ "compile",
"--r7rs",
"--load-path=" ++ root,
"--output=" ++ root </> intdir </> replaceExtension path ".scm.go",
path
]
when (isJust out) <| do
let o = Maybe.fromJust out
writeFile
(root </> bindir </> o)
<| Text.pack
<| joinWith
"\n"
[ "#!/usr/bin/env bash",
"guile -C \""
<> root </> intdir
<> "\" -c \"(use-modules "
<> Namespace.toSchemeModule namespace
<> ") (main (command-line))\""
<> " \"$@\""
]
p <- Dir.getPermissions <| root </> bindir </> o
Dir.setPermissions (root </> bindir </> o) (Dir.setOwnerExecutable True p)
pure Exit.ExitSuccess
NixBuild -> do
Log.info
[ "bild",
"nix",
if Text.null builder
then "local"
else builder,
nschunk namespace
]
proc
loud
namespace
"nix-build"
[ path,
"-o",
root </> nixdir </> Namespace.toPath namespace,
"--builders",
Text.unpack builder
]
Copy -> do
Log.warn ["bild", "copy", "TODO", nschunk namespace]
pure Exit.ExitSuccess
data Proc = Proc
{ loud :: Bool,
cmd :: String,
args :: [String],
ns :: Namespace,
onFailure :: IO (),
onSuccess :: IO ()
}
-- | Run a subprocess, streaming output if --loud is set.
run :: Proc -> IO Exit.ExitCode
run Proc {..} = do
(Conduit.Inherited, stdout_, stderr_, cph) <- Conduit.streamingProcess <| Conduit.proc cmd args
exitcode <-
if loud
then
Async.runConcurrently
<| Async.Concurrently (puts stdout_)
*> (Async.Concurrently <| Conduit.waitForStreamingProcess cph)
else
Async.runConcurrently
<| Async.Concurrently
<| Conduit.waitForStreamingProcess cph
if isFailure exitcode
then puts stderr_ >> onFailure >> pure exitcode
else onSuccess >> pure exitcode
-- | Helper for running a standard bild subprocess.
proc :: Bool -> Namespace -> String -> [String] -> IO Exit.ExitCode
proc loud namespace cmd args =
run
<| Proc
{ loud = loud,
ns = namespace,
cmd = cmd,
args = args,
onFailure = Log.fail ["bild", nschunk namespace] >> Log.br,
onSuccess = Log.good ["bild", nschunk namespace] >> Log.br
}
-- | Helper for printing during a subprocess
puts :: Conduit.ConduitM () ByteString IO () -> IO ()
puts thing = Conduit.runConduit <| thing .| Conduit.mapM_ putStr
nschunk :: Namespace -> Text
nschunk = Namespace.toPath .> Text.pack
metaDep :: Regex.RE Char Dep
metaDep = Regex.string "-- : dep " *> Regex.many (Regex.psym Char.isAlpha)
metaSys :: [Char] -> Regex.RE Char Dep
metaSys comment = Regex.string (comment ++ " : sys ") *> Regex.many (Regex.psym Char.isAlpha)
metaOut :: [Char] -> Regex.RE Char Out
metaOut comment = Regex.string (comment ++ " : out ") *> Regex.many (Regex.psym (/= ' '))
haskellImports :: Regex.RE Char String
haskellImports =
Regex.string "import"
*> Regex.some (Regex.psym Char.isSpace)
*> Regex.many (Regex.psym Char.isLower)
*> Regex.many (Regex.psym Char.isSpace)
*> Regex.some (Regex.psym isModuleChar)
<* Regex.many Regex.anySym
where
isModuleChar c =
elem c <| concat [['A' .. 'Z'], ['a' .. 'z'], ['.', '_'], ['0' .. '9']]