firefly-compiler 0.4.4

package/compiler/Dependencies.ff

@@ -0,0 +1,179 @@
+import Parser
+import Syntax
+import Tokenizer
+import Workspace
+import LspHook
+
+capability Dependencies(
+    workspace: Workspace
+    mutable packages: Map[PackagePair, PackageInfo]
+    mutable packagePaths: Map[PackagePair, Path]
+    mutable singleFilePackages: Set[PackagePair]
+)
+
+capability ResolvedDependencies(
+    mainPackagePair: PackagePair
+    packages: Map[PackagePair, PackageInfo]
+    packagePaths: Map[PackagePair, Path]
+    singleFilePackages: Set[PackagePair]
+)
+
+extend self: Dependencies {
+
+    loadPackageInfo(
+        packagePair: PackagePair
+        path: Path
+    ): PackageInfo {
+        let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+        let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
+        let packageFile = if(sharedPackageFile.exists()) {
+            sharedPackageFile
+        } else {
+            self.singleFilePackages = self.singleFilePackages.add(packagePair)
+            path
+        }
+        let code = packageFile.readText()
+        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
+    }
+    
+    parsePackageFile(
+        packagePair: PackagePair
+        fileName: String
+        code: String
+    ): PackageInfo {
+        let tokens = Tokenizer.tokenize(fileName, code, None, True)
+        let parser = Parser.make(packagePair, fileName, tokens, False, LspHook.disabled())
+        let info = parser.parsePackageInfo()
+        self.addCoreDependencyIfMissing(info)
+    }
+
+    addCoreDependencyIfMissing(info: PackageInfo): PackageInfo {
+        if(info.dependencies.any {d =>
+            d.packagePair.group == "ff" && d.packagePair.name == "core"
+        }) {
+            info
+        } else {
+            let coreDependency = DDependency(
+                at = info.package.at
+                packagePair = PackagePair("ff", "core")
+                version = Version(info.package.at, 0, 0, 0)
+                safety = Trusted
+                targets = info.package.targets
+            )
+            info.PackageInfo(dependencies = [coreDependency, ...info.dependencies])
+        }
+    }
+
+    processPackageInfo(
+        packageInfo: PackageInfo
+    ): List[DDependency] {
+        self.packages = self.packages.add(packageInfo.package.packagePair, packageInfo)
+        packageInfo.dependencies.filter {!self.packages.contains(_.packagePair)}
+    }
+
+    fetchDependency(
+        path: Path
+        httpClient: HttpClient
+        dependency: DDependency
+    ): Path {
+        let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
+        if(location.contains(":") && !location.dropFirst(1).startsWith(":")) {
+            if(location.startsWith("http://") || location.startsWith("https://")) {
+                let packagePair = dependency.packagePair
+                let directory = if(path.isDirectory()) {path} else {path.parent().grab()}
+                let dependenciesPath = directory.slash(".firefly").slash("dependencies")
+                let dependencyPath = dependenciesPath.slash(packagePair.group).slash(packagePair.name)
+                let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
+                let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
+                if(!donePath.exists()) {
+                    Log.trace("Fetching " + location)
+                    let response = httpClient.fetch(location, throw = False)
+                    if(!response.ok()) {
+                        panic("Could not download dependency: " + location)
+                    }
+                    let buffer = response.readBuffer()
+                    if(dependencyPath.exists()) {
+                        dependencyPath.delete()
+                    }
+                    dependencyPath.createDirectory(createParentDirectories = True)
+                    tarGzPath.writeStream([buffer].toStream())
+                    internalExtractTarGz(tarGzPath, dependencyPath)
+                    tarGzPath.renameTo(donePath)
+                }
+                dependencyPath
+            } else {
+                panic("Loading packages by this protocol is not supported: " + location)
+            }
+        } else {
+            path.path(location)
+        }
+    }
+
+    processDependencies(
+        path: Path
+        httpClient: HttpClient
+        dependencies: List[DDependency]
+    ): Unit {
+        // Remember to check for cycles
+        let packageInfos = dependencies.map {dependency =>
+            let dependencyPath = self.fetchDependency(path, httpClient, dependency)
+            self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
+            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
+            checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
+            packageInfo
+        }
+        let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
+        if(newDependencies != []) {
+            self.processDependencies(path, httpClient, newDependencies)
+        }
+    }
+
+}
+
+process(fetch: HttpClient, path: Path): ResolvedDependencies {
+    let workspace = Workspace.loadWorkspace(path)
+    let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
+    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path)
+    let newDependencies = self.processPackageInfo(packageInfo)
+    self.processDependencies(path, fetch, newDependencies)
+    let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
+    ResolvedDependencies(
+        mainPackagePair = packageInfo.package.packagePair
+        packages = self.packages
+        packagePaths = packagePaths
+        singleFilePackages = self.singleFilePackages
+    )
+}
+
+findScriptPackageLocation(path: Path): Path {
+    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+    function go(directory: Path): Path {
+        let packageFile = directory.slash(".firefly").slash("package.ff")
+        if(packageFile.exists()) {
+            directory
+        } elseIf {!directory.parent().isEmpty()} {
+            go(directory.parent().grab())
+        } else {
+            packageDirectory
+        }
+    }
+    go(packageDirectory)
+}
+
+checkPackagePairs(dependencyPair: PackagePair, packagePair: PackagePair): Unit {
+    if(
+        packagePair.group != dependencyPair.group ||
+        packagePair.name != dependencyPair.name
+    ) {
+        panic(
+            "Dependency declaration and package declaration disagree on package name: " +
+            dependencyPair.groupName() + " vs. " + packagePair.groupName()
+        )
+    }
+}
+
+internalExtractTarGz(tarGzPath: Path, path: Path): Unit
+    target node async """
+        import * as tar from 'tar'
+        await tar.extract({file: tarGzPath_, cwd: path_, strict: true})
+    """