Add Compiler.Outline.findSourceFiles

Author: robinheghan

src/Compiler/Outline.gren

@@ -3,13 +3,18 @@ module Compiler.Outline exposing
     , AppOutline
     , PkgOutline
     , VersionConstraint(..)
+    --
+    , findSourceFiles
+    --
     , jsonDecoder
     , toJson
     )
 
 
+import Bytes
 import SemanticVersion exposing (SemanticVersion)
 import SemanticVersionRange exposing (SemanticVersionRange)
+import FileSystem
 import FileSystem.Path as Path exposing (Path)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
@@ -18,6 +23,7 @@ import Compiler.ModuleName as ModuleName exposing (ModuleName)
 import Compiler.License as License exposing (License)
 import Compiler.Platform as Platform exposing (Platform)
 import Dict exposing (Dict)
+import Task exposing (Task)
 
 
 type Outline
@@ -58,6 +64,69 @@ type VersionConstraint a
     | LocalPath Path
 
 
+findSourceFiles : FileSystem.Permission -> Outline -> Path -> Task FileSystem.Error (Array { moduleName : String, source : String })
+findSourceFiles fsPerm outline outlinePath =
+    let
+        sourceDirs =
+            when outline is
+                App appOutline ->
+                    appOutline.sourceDirectories
+
+                Pkg _ ->
+                    [ Path.fromPosixString "src"
+                    ]
+    in
+    Array.map (\srcDir -> Path.append srcDir outlinePath) sourceDirs
+        |> Array.map (findSourceFilesHelp fsPerm Path.empty)
+        |> Task.sequence
+        |> Task.map Array.flatten
+        |> Task.andThen (\paths -> Task.sequence <| Array.map (readSourceFile fsPerm) paths)
+
+
+findSourceFilesHelp : FileSystem.Permission -> Path -> Path -> Task FileSystem.Error (Array { absolute : Path, relative : Path })
+findSourceFilesHelp fsPerm local root =
+    FileSystem.listDirectory fsPerm root
+        |> Task.andThen
+            (\paths ->
+                paths
+                    |> Array.mapAndKeepJust
+                        (\entry ->
+                            when entry.entityType is
+                                FileSystem.Directory ->
+                                    Just <| findSourceFilesHelp fsPerm (Path.append entry.path local) (Path.append entry.path root)
+
+                                FileSystem.File ->
+                                    if entry.path.extension == "js" || entry.path.extension == "gren" then
+                                        Just <| Task.succeed [ { absolute = Path.append entry.path root, relative = Path.append entry.path local } ]
+
+                                    else
+                                        Nothing
+
+                                _ ->
+                                    Nothing
+                        )
+                    |> Task.sequence
+                    |> Task.map Array.flatten
+            )
+
+
+readSourceFile : FileSystem.Permission -> { absolute : Path, relative : Path } -> Task FileSystem.Error { moduleName : String, source : String }
+readSourceFile fsPerm { absolute, relative } =
+    FileSystem.readFile fsPerm absolute
+        |> Task.map
+            (\source ->
+                { moduleName =
+                    { relative | extension = "" }
+                        |> Path.toPosixString
+                        |> String.replace "/" "."
+                , source =
+                    -- TODO: Error
+                    Bytes.toString source
+                        |> Maybe.withDefault ""
+                }
+            )
+
+
 jsonDecoder : Decoder Outline
 jsonDecoder =
     Decode.field "type" Decode.string