[POC] Elm json "source-directories" support

data/default.nix

@@ -1,42 +1,54 @@
 { nixpkgs ? <nixpkgs>
 , config ? {}
 }:
-
 with (import nixpkgs config);
-
 let
   mkDerivation =
-    { srcs ? ./elm-srcs.nix
-    , src
+    { elmsrcs ? ./elm-srcs.nix
+    , srcs
+    , srcdir ? "src"
     , name
-    , srcdir ? "./src"
     , targets ? []
     , versionsDat ? ./versions.dat
     }:
-    stdenv.mkDerivation {
-      inherit name src;
+    let sanitizePath = str:
+        let path = builtins.filter (p: p != "..") (lib.splitString "/" str);
+        in lib.concatStringsSep "/" (map (p: if p == "." then srcdir else p) path);
+    in stdenv.mkDerivation {
+      inherit name srcs;
+      sourceRoot = ".";
 
       buildInputs = [ elmPackages.elm ];
 
+      patchPhase = let
+        elmjson = let json = (lib.importJSON ./elm.json) // { source-directories = map sanitizePath srcs; };
+        in writeText "elm.json" (builtins.toJSON json);
+      in ''
+        echo "Generating elm.json"
+        cp \${elmjson} ./elm.json
+        cat elm.json
+      '';
+
       buildPhase = pkgs.elmPackages.fetchElmDeps {
-        elmPackages = import srcs;
+        elmPackages = import elmsrcs;
         inherit versionsDat;
       };
 
-      installPhase = let
-        elmfile = module: "\${srcdir}/\${builtins.replaceStrings ["."] ["/"] module}.elm";
-      in ''
-        mkdir -p \$out/share/doc
-        \${lib.concatStrings (map (module: ''
-          echo "compiling \${elmfile module}"
-          elm make \${elmfile module} --output \$out/\${module}.html --docs \$out/share/doc/\${module}.json
-        '') targets)}
+      installPhase = ''
+        mkdir -p $out/share/doc
+
+        \${lib.concatStrings (map (module:
+          let fullmodule = sanitizePath module;
+              modulename = sanitizePath (lib.removePrefix "./" module);
+          in ''
+            echo "compiling \${module}"
+            elm make \${fullmodule}.elm --output $out/\${modulename}.html --docs $out/share/doc/\${modulename}.json
+          '') targets)}
       '';
     };
 in mkDerivation {
   name = "${name}";
-  srcs = ./elm-srcs.nix;
-  src = ./.;
-  targets = ["Main"];
+  srcs = ${srcs};
   srcdir = "${srcdir}";
+  targets = ["./Main"];
 }

elm2nix.cabal

@@ -45,6 +45,8 @@ library
     , text
     , transformers
     , unordered-containers
+    , vector
+    , directory
   exposed-modules:
       Elm2Nix
       Elm2Nix.FixedOutput

src/Elm2Nix.hs

@@ -17,13 +17,16 @@ import Data.List (intercalate)
 import Data.HashMap.Strict (HashMap)
 import Data.String.Here
 import Data.Text (Text)
+import Data.Vector (Vector)
 import System.Exit (exitFailure)
 import System.IO (hPutStrLn, stderr)
 
+import qualified System.Directory
 import qualified Data.HashMap.Strict as HM
 import qualified Data.ByteString.Lazy as LBS
 import qualified Data.Aeson as Json
 import qualified Data.Text as Text
+import qualified Data.Vector as Vector
 
 import Elm2Nix.FixedOutput (FixedDerivation(..), prefetch)
 import Elm2Nix.PackagesSnapshot (snapshot)
@@ -67,13 +70,40 @@ parseElmJsonDeps obj =
     parseDeps (Object hm) = mapM (uncurry parseDep) (HM.toList hm)
     parseDeps v           = Left (UnexpectedValue v)
 
+-- TODO: there is likely to be even better abstraction
+tryLookup :: HashMap Text Value -> Text -> Either Elm2NixError Value
+tryLookup hm key = maybeToRight (KeyNotFound key) (HM.lookup key hm)
+  where
     maybeToRight :: b -> Maybe a -> Either b a
     maybeToRight _ (Just x) = Right x
     maybeToRight y Nothing  = Left y
 
-    tryLookup :: HashMap Text Value -> Text -> Either Elm2NixError Value
-    tryLookup hm key =
-      maybeToRight (KeyNotFound key) (HM.lookup key hm)
+parseElmJsonSrcs :: Value -> Either Elm2NixError (Vector FilePath)
+parseElmJsonSrcs obj =
+  case obj of
+    Object hm -> do
+      case tryLookup hm "source-directories" of
+        -- the `source-directories` part of elm.json is optional
+        -- if user don't specified this value `src` directory is the default
+        Left _ -> Right $ pure "./src"
+        Right srcs ->
+          case srcs of
+            Array vec -> mapM extractSrcPath vec
+            v -> Left $ UnexpectedValue v
+    v -> Left $ UnexpectedValue v
+  where
+    extractSrcPath :: Value -> Either Elm2NixError String
+    extractSrcPath val =
+      case val of
+        String text -> Right (toNixPath (Text.unpack text))
+        v -> Left $ UnexpectedValue v
+
+    toNixPath :: FilePath -> FilePath
+    toNixPath path =
+      case path of
+        "."       -> "./."
+        p@('.':_) -> p
+        p         -> "./" <> p
 
 -- CMDs
 
@@ -90,7 +120,17 @@ convert = runCLI $ do
   liftIO (putStrLn (generateNixSources sources))
 
 initialize :: IO ()
-initialize = runCLI $
+initialize = runCLI $ do
+  liftIO (hPutStrLn stderr "Resolving elm.json source directories into Nix paths...")
+  res <- liftIO (fmap Json.eitherDecode (LBS.readFile "elm.json"))
+  elmJson <- either (throwErr . ElmJsonReadError) return res
+
+  srcs' <- either throwErr return (parseElmJsonSrcs elmJson)
+  liftIO (hPutStrLn stderr $ "Using source directories:")
+  liftIO (mapM (hPutStrLn stderr) srcs')
+  let srcs = stringifySrcs srcs'
+  srcdir <- liftIO (getSrcDir srcs')
+
   liftIO (putStrLn [template|data/default.nix|])
   where
     -- | Converts Package.Name to Nix friendly name
@@ -102,8 +142,29 @@ initialize = runCLI $
     toNixName = Text.replace "/" "-"
     name :: String
     name = Text.unpack (toNixName baseName <> "-" <> version)
-    srcdir :: String
-    srcdir = "./src" -- TODO: get from elm.json
+    getSrcDir :: Vector FilePath -> IO FilePath
+    getSrcDir dirs =
+      case Vector.toList dirs of
+        []       -> pure "./src" -- in theory redundant
+        [ dir ]  -> pure dir
+        xs@(h:t) ->
+          if "./." `elem` xs then do
+            -- Nix creates dir named after current directory
+            -- if `srcs` contains `./.`
+            path <- liftIO System.Directory.getCurrentDirectory
+            pure (lastDir path)
+          else
+            -- We can't really tell which one to choose
+            -- so we guess it's the first one
+            pure h
+    lastDir :: FilePath -> FilePath
+    lastDir = foldl (\path c -> if c == '/' then "" else path <> [c]) ""
+    -- TODO: Improve
+    stringifySrcs :: Vector FilePath -> String
+    stringifySrcs xs =
+      "[\n"
+      <> foldr (\i acc -> "    " <> i <> "\n" <> acc) "" xs
+      <> "  ]"
 
 -- Utils