write mod.rs files for sub-modules

Author: ners

inline-rust.cabal

@@ -47,6 +47,7 @@ library
                      , ScopedTypeVariables
 
   build-depends:       base                 >=4.9 && <5.0
+                     , extra                >=0.5
                      , language-rust        >=0.2.0
                      , prettyprinter        >=1.1
                      , process              >=1.4

src/Language/Rust/Inline/Internal.hs

@@ -37,8 +37,9 @@ import Data.Maybe                  ( fromMaybe )
 import Data.List                   ( unfoldr )
 import Data.Char                   ( isAlpha, isAlphaNum )
 
-import System.FilePath             ( (</>), (<.>), takeDirectory, takeExtension )
-import System.Directory            ( copyFile, createDirectoryIfMissing, getDirectoryContents )
+import System.FilePath             ( (</>), (<.>), takeBaseName, takeDirectory, takeExtension )
+import System.Directory            ( copyFile, createDirectoryIfMissing )
+import System.Directory.Extra      ( listFilesRecursive )
 import System.Process              ( spawnProcess, readProcess, waitForProcess )
 import System.Exit                 ( ExitCode(..) )
 import System.Environment          ( setEnv )
@@ -71,8 +72,8 @@ initCodeBlocks dependenciesOpt = do
 
   -- add hooks for writing out files (and possibly compiling the project)
   let finalizer = case dependenciesOpt of
-                    Nothing -> fileFinalizer 
-                    Just deps -> fileFinalizer *> cargoFinalizer [] deps
+                    Nothing -> fileFinalizer True
+                    Just deps -> fileFinalizer False *> cargoFinalizer [] deps
   addModFinalizer finalizer
 
   -- add a module state
@@ -150,24 +151,22 @@ cargoFinalizer :: [String]           -- ^ Extra @cargo@ arguments
                -> [(String, String)] -- ^ Dependencies
                -> Q ()
 cargoFinalizer extraArgs dependencies = do
-  (pkg, mods) <- currentFile
+  (pkg, _) <- currentFile
 
-  let dir = ".inline-rust" </> pkg
-      thisFile = foldr1 (</>) mods <.> "rs"
+  let pkgDir = ".inline-rust" </> pkg
+      srcDir = pkgDir </> "src"
       crate = "quasiquote_" ++ pkg
 
-  nameFiles <- map (dir </>) . filter ((".ffinames" ==) . takeExtension) <$> runIO (getDirectoryContents dir)
-  runIO $ print nameFiles
+  nameFiles <- filter ((".ffinames" ==) . takeExtension) <$> runIO (listFilesRecursive srcDir)
   names <- runIO $ concat <$> forM nameFiles (fmap lines . readFile)
-  runIO $ print names
   ffiFakeSig <- [t| IO () |]
   forM_ names $ \name -> do
     name' <- newName $ name <> "_fake"
     let ffiImport = ForeignD (ImportF CCall Unsafe name name' ffiFakeSig)
     addTopDecls [ffiImport]
 
   -- Make contents of a @Cargo.toml@ file
-  let cargoToml = dir </> "Cargo" <.> "toml"
+  let cargoToml = pkgDir </> "Cargo" <.> "toml"
       cargoSrc = unlines [ "[package]"
                          , "name = \"" ++ crate ++ "\""
                          , "version = \"0.0.0\""
@@ -178,11 +177,11 @@ cargoFinalizer extraArgs dependencies = do
                                    ]
 
                          , "[lib]"
-                         , "path = \"" ++ thisFile ++ "\""
                          , "crate-type = [\"staticlib\"]"
                          ]
-  runIO $ createDirectoryIfMissing True dir
-  runIO $ writeFile cargoToml cargoSrc
+  runIO $ do
+    createDirectoryIfMissing True pkgDir
+    writeFile cargoToml cargoSrc
 
   -- Run Cargo to compile the project
   --
@@ -242,12 +241,22 @@ rustcErrMsg = "Rust source file associated with this module failed to compile"
 -- a module. This emits into a file in the @.inline-rust@ directory all of the
 -- Rust code we have produced while processing the current files contexts and
 -- quasiquotes.
-fileFinalizer :: Q ()
-fileFinalizer = do
+fileFinalizer :: Bool -> Q ()
+fileFinalizer submodule = do
   (pkg, mods) <- currentFile
 
-  let dir = ".inline-rust" </> pkg
-      thisFile = foldr1 (</>) mods
+  let pkgDir = ".inline-rust" </> pkg
+      srcDir = pkgDir </> "src"
+      thisFile = if submodule then foldr1 (</>) mods else "lib"
+
+  when submodule $ do
+    let modPaths = tail $ (srcDir </>) <$> scanl1 (</>) mods
+    forM_ modPaths $ \modPath -> runIO $ do
+      let modName = takeBaseName modPath
+          modDir = takeDirectory modPath
+          modFile = modDir </> "mod.rs"
+      createDirectoryIfMissing True modDir
+      appendFile modFile $ "pub mod " <> modName <> ";\n"
 
   -- Figure out what we are putting into this file 
   Just cb <- getQ
@@ -262,13 +271,13 @@ fileFinalizer = do
            $ ""
 
   -- Write out the file
-  let filepath = dir </> thisFile <.> "rs"
+  let filepath = srcDir </> thisFile <.> "rs"
   runIO $ do
     createDirectoryIfMissing True $ takeDirectory filepath
     writeFile filepath code
 
   Just (FFINames names) <- getQ
-  let namesFile = dir </> foldr1 (<.>) mods <.> "ffinames"
+  let namesFile = srcDir </> foldr1 (<.>) mods <.> "ffinames"
   runIO . writeFile namesFile . unlines $ names
 
 -- | Figure out what file we are currently in.