From 993dec16f6d7e28e90cc02576e5130280e5544cd Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Wed, 19 Jul 2023 13:49:38 -0700 Subject: [PATCH 1/9] WIP - add script --- scripts/src/CompilerVersions.purs | 151 ++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 scripts/src/CompilerVersions.purs diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs new file mode 100644 index 00000000..06447f8a --- /dev/null +++ b/scripts/src/CompilerVersions.purs @@ -0,0 +1,151 @@ +module Registry.Scripts.CompilerVersions where + +import Registry.App.Prelude + +import Data.Array as Array +import Data.Formatter.DateTime as Formatter.DateTime +import Data.Map as Map +import Data.String as String +import Effect.Class.Console as Console +import Effect.Ref as Ref +import Node.Path as Path +import Node.Process as Process +import Registry.App.CLI.Git as Git +import Registry.App.Effect.Cache as Cache +import Registry.App.Effect.Env as Env +import Registry.App.Effect.GitHub as GitHub +import Registry.App.Effect.Log (LOG) +import Registry.App.Effect.Log as Log +import Registry.App.Effect.Registry (REGISTRY) +import Registry.App.Effect.Registry as Registry +import Registry.Foreign.FSExtra as FS.Extra +import Registry.Foreign.Octokit as Octokit +import Registry.Internal.Format as Internal.Format +import Registry.License as License +import Registry.Location as Location +import Registry.Manifest (Manifest(..)) +import Registry.ManifestIndex (toSortedArray) +import Registry.PackageName as PackageName +import Registry.Range as Range +import Registry.Solver as Solver +import Registry.Version as Version +import Run (Run, EFFECT) +import Run as Run +import Run.Except (EXCEPT) +import Run.Except as Except + +main :: Effect Unit +main = launchAff_ do + -- Environment + _ <- Env.loadEnvFile ".env" + token <- Env.lookupRequired Env.pacchettibottiToken + + -- Caching + let cache = Path.concat [ scratchDir, ".cache" ] + FS.Extra.ensureDirectory cache + githubCacheRef <- Cache.newCacheRef + registryCacheRef <- Cache.newCacheRef + + -- GitHub + octokit <- Octokit.newOctokit token + + -- Registry + debouncer <- Registry.newDebouncer + let + registryEnv :: Registry.RegistryEnv + registryEnv = + { write: Registry.ReadOnly + , pull: Git.Autostash + , repos: Registry.defaultRepos + , workdir: scratchDir + , debouncer + , cacheRef: registryCacheRef + } + + -- Logging + now <- nowUTC + let logDir = Path.concat [ scratchDir, "logs" ] + FS.Extra.ensureDirectory logDir + let logFile = "verify-" <> String.take 19 (Formatter.DateTime.format Internal.Format.iso8601DateTime now) <> ".log" + let logPath = Path.concat [ logDir, logFile ] + Console.log $ "Logs available at " <> logPath + + solveCompilerVersions + # Except.catch (\error -> Run.liftEffect (Console.log error *> Process.exit 1)) + # Registry.interpret (Registry.handle registryEnv) + # GitHub.interpret (GitHub.handle { octokit, cache, ref: githubCacheRef }) + # Log.interpret (\log -> Log.handleTerminal Normal log *> Log.handleFs Verbose logPath log) + # Run.runBaseAff' + +solveCompilerVersions :: forall r. Run (LOG + EFFECT + REGISTRY + EXCEPT String + r) Unit +solveCompilerVersions = do + --allMetadata <- Registry.readAllMetadata + allManifests <- Registry.readAllManifests + let + compilerPackage = unsafeFromRight $ PackageName.parse "compiler" + compilerVersions = map (unsafeFromRight <<< Version.parse) + [ "0.13.0" + , "0.13.2" + , "0.13.3" + , "0.13.4" + , "0.13.5" + , "0.13.6" + , "0.13.8" + , "0.14.0" + , "0.14.1" + , "0.14.2" + , "0.14.3" + , "0.14.4" + , "0.14.5" + , "0.14.6" + , "0.14.7" + , "0.14.8" + , "0.14.9" + , "0.15.0" + , "0.15.2" + , "0.15.3" + , "0.15.4" + , "0.15.5" + , "0.15.6" + , "0.15.7" + , "0.15.8" + , "0.15.9" + , "0.15.10" + ] + + compilerManifests = do + let + go :: Version -> Maybe (Tuple Version Manifest) + go version = do + license <- hush $ License.parse "MIT" + pure $ Tuple version $ Manifest + { name: compilerPackage + , version + , license + , location: Location.GitHub { owner: "purescript", repo: "purescript", subdir: Nothing } + , owners: Nothing + , description: Nothing + , files: Nothing + , dependencies: Map.empty + } + + Map.fromFoldable + [ Tuple compilerPackage $ Map.fromFoldable $ Array.mapMaybe go compilerVersions + ] + + newManifestsRef <- liftEffect $ Ref.new compilerManifests + + for_ (toSortedArray allManifests) \manifest -> do + let + getDependencies = _.dependencies <<< un Manifest + + insertCompilerDependency :: Manifest -> Version -> Manifest + insertCompilerDependency (Manifest manifest) version = Manifest $ manifest + { dependencies = Map.insert compilerPackage (unsafeFromJust (Range.mk version (Version.bumpMinor version))) manifest.dependencies + } + + newManifests <- liftEffect $ Ref.read newManifestsRef + Log.info "here" + pure $ Solver.solve (map (map getDependencies) newManifests) (getDependencies manifest) + + pure unit From c54a6172f0baa4358462169b65ba4a98e54d6863 Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Thu, 20 Jul 2023 12:08:34 -0700 Subject: [PATCH 2/9] Script to compute supported compiler versions for a single package with no dependencies --- scripts/src/CompilerVersions.purs | 221 ++++++++++++++++++------------ 1 file changed, 136 insertions(+), 85 deletions(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index 06447f8a..7a9512d5 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -2,15 +2,22 @@ module Registry.Scripts.CompilerVersions where import Registry.App.Prelude +import ArgParse.Basic (ArgParser) +import ArgParse.Basic as Arg import Data.Array as Array +import Data.Array.NonEmpty as NEA import Data.Formatter.DateTime as Formatter.DateTime import Data.Map as Map import Data.String as String +import Data.Tuple (uncurry) import Effect.Class.Console as Console -import Effect.Ref as Ref +import Node.FS.Aff as FS.Aff import Node.Path as Path import Node.Process as Process import Registry.App.CLI.Git as Git +import Registry.App.CLI.Purs as Purs +import Registry.App.CLI.PursVersions as PursVersions +import Registry.App.CLI.Tar as Tar import Registry.App.Effect.Cache as Cache import Registry.App.Effect.Env as Env import Registry.App.Effect.GitHub as GitHub @@ -18,27 +25,64 @@ import Registry.App.Effect.Log (LOG) import Registry.App.Effect.Log as Log import Registry.App.Effect.Registry (REGISTRY) import Registry.App.Effect.Registry as Registry +import Registry.App.Effect.Storage (STORAGE) +import Registry.App.Effect.Storage as Storage import Registry.Foreign.FSExtra as FS.Extra import Registry.Foreign.Octokit as Octokit +import Registry.Foreign.Tmp as Tmp import Registry.Internal.Format as Internal.Format -import Registry.License as License -import Registry.Location as Location import Registry.Manifest (Manifest(..)) -import Registry.ManifestIndex (toSortedArray) +import Registry.ManifestIndex as ManifestIndex import Registry.PackageName as PackageName import Registry.Range as Range -import Registry.Solver as Solver import Registry.Version as Version -import Run (Run, EFFECT) +import Run (EFFECT, Run, AFF) import Run as Run -import Run.Except (EXCEPT) +import Run.Except (EXCEPT, rethrow, throw) import Run.Except as Except +data InputMode + = File FilePath + | Package PackageName Version + | AllPackages + +parser :: ArgParser InputMode +parser = Arg.choose "input (--file or --package or --all)" + [ Arg.argument [ "--file" ] + """Verify packages from a JSON file like: [ "prelude", "console" ]""" + # Arg.unformat "FILE_PATH" pure + # map File + , Arg.argument [ "--package" ] + "Verify the indicated package" + # Arg.unformat "NAME@VERSION" parsePackage + # map (uncurry Package) + , Arg.flag [ "--all" ] "Verify all packages" $> AllPackages + ] + where + parsePackage :: String -> Either String (Tuple PackageName Version) + parsePackage input = do + let split = String.split (String.Pattern "@") input + case Array.length split of + 0 -> Left "Expected package@version but received nothing." + 2 -> do + rawPackage <- note "Unexpected error" (Array.index split 0) + package <- lmap (append ("Failed to parse package name '" <> rawPackage <> "': ")) (PackageName.parse rawPackage) + rawVersion <- note "Unexpected error" (Array.index split 1) + version <- lmap (append ("Failed to parse version '" <> rawVersion <> "': ")) (Version.parse rawVersion) + pure $ Tuple package version + _ -> Left $ "Expected package@version but received an invalid format: " <> input + main :: Effect Unit main = launchAff_ do + args <- Array.drop 2 <$> liftEffect Process.argv + let description = "A script for determining the supported compiler versions for packages." + arguments <- case Arg.parseArgs "compiler-versions" description parser args of + Left err -> Console.log (Arg.printArgError err) *> liftEffect (Process.exit 1) + Right command -> pure command + -- Environment _ <- Env.loadEnvFile ".env" - token <- Env.lookupRequired Env.pacchettibottiToken + token <- Env.lookupRequired Env.githubToken -- Caching let cache = Path.concat [ scratchDir, ".cache" ] @@ -66,86 +110,93 @@ main = launchAff_ do now <- nowUTC let logDir = Path.concat [ scratchDir, "logs" ] FS.Extra.ensureDirectory logDir - let logFile = "verify-" <> String.take 19 (Formatter.DateTime.format Internal.Format.iso8601DateTime now) <> ".log" + let logFile = "compiler-versions-" <> String.take 19 (Formatter.DateTime.format Internal.Format.iso8601DateTime now) <> ".log" let logPath = Path.concat [ logDir, logFile ] Console.log $ "Logs available at " <> logPath - solveCompilerVersions - # Except.catch (\error -> Run.liftEffect (Console.log error *> Process.exit 1)) - # Registry.interpret (Registry.handle registryEnv) - # GitHub.interpret (GitHub.handle { octokit, cache, ref: githubCacheRef }) - # Log.interpret (\log -> Log.handleTerminal Normal log *> Log.handleFs Verbose logPath log) - # Run.runBaseAff' - -solveCompilerVersions :: forall r. Run (LOG + EFFECT + REGISTRY + EXCEPT String + r) Unit -solveCompilerVersions = do - --allMetadata <- Registry.readAllMetadata - allManifests <- Registry.readAllManifests let - compilerPackage = unsafeFromRight $ PackageName.parse "compiler" - compilerVersions = map (unsafeFromRight <<< Version.parse) - [ "0.13.0" - , "0.13.2" - , "0.13.3" - , "0.13.4" - , "0.13.5" - , "0.13.6" - , "0.13.8" - , "0.14.0" - , "0.14.1" - , "0.14.2" - , "0.14.3" - , "0.14.4" - , "0.14.5" - , "0.14.6" - , "0.14.7" - , "0.14.8" - , "0.14.9" - , "0.15.0" - , "0.15.2" - , "0.15.3" - , "0.15.4" - , "0.15.5" - , "0.15.6" - , "0.15.7" - , "0.15.8" - , "0.15.9" - , "0.15.10" - ] - - compilerManifests = do - let - go :: Version -> Maybe (Tuple Version Manifest) - go version = do - license <- hush $ License.parse "MIT" - pure $ Tuple version $ Manifest - { name: compilerPackage - , version - , license - , location: Location.GitHub { owner: "purescript", repo: "purescript", subdir: Nothing } - , owners: Nothing - , description: Nothing - , files: Nothing - , dependencies: Map.empty - } - - Map.fromFoldable - [ Tuple compilerPackage $ Map.fromFoldable $ Array.mapMaybe go compilerVersions - ] - - newManifestsRef <- liftEffect $ Ref.new compilerManifests - - for_ (toSortedArray allManifests) \manifest -> do - let - getDependencies = _.dependencies <<< un Manifest - - insertCompilerDependency :: Manifest -> Version -> Manifest - insertCompilerDependency (Manifest manifest) version = Manifest $ manifest - { dependencies = Map.insert compilerPackage (unsafeFromJust (Range.mk version (Version.bumpMinor version))) manifest.dependencies - } + runDetermineCompilerVersionsForPackage :: PackageName -> Version -> Aff Unit + runDetermineCompilerVersionsForPackage package version = + determineCompilerVersionsForPackage package version + # Except.catch (\error -> Run.liftEffect (Console.log error *> Process.exit 1)) + # Registry.interpret (Registry.handle registryEnv) + # Storage.interpret (Storage.handleReadOnly cache) + # GitHub.interpret (GitHub.handle { octokit, cache, ref: githubCacheRef }) + # Log.interpret (\log -> Log.handleTerminal Normal log *> Log.handleFs Verbose logPath log) + # Run.runBaseAff' + + case arguments of + File _ -> Console.log "Unsupported at this time." *> liftEffect (Process.exit 1) + Package package version -> runDetermineCompilerVersionsForPackage package version + AllPackages -> Console.log "Unsupported at this time." *> liftEffect (Process.exit 1) + +determineCompilerVersionsForPackage :: forall r. PackageName -> Version -> Run (AFF + EFFECT + REGISTRY + EXCEPT String + LOG + STORAGE + r) Unit +determineCompilerVersionsForPackage package version = do + allManifests <- map ManifestIndex.toMap Registry.readAllManifests + compilerVersions <- PursVersions.pursVersions + Log.debug $ "Checking Manifest Index for " <> formatPackageVersion package version + Manifest { dependencies } <- rethrow $ (note "Invalid Version" <<< Map.lookup version <=< note "Invalid PackageName" <<< Map.lookup package) allManifests + unless (Map.isEmpty dependencies) do + Log.error "Cannot check package that has dependencies." + throw "Cannot check package that has dependencies." + tmp <- Run.liftAff Tmp.mkTmpDir + let formattedName = formatPackageVersion package version + let extractedName = PackageName.print package <> "-" <> Version.print version + let tarballName = extractedName <> ".tar.gz" + let tarballPath = Path.concat [ tmp, tarballName ] + let extractedPath = Path.concat [ tmp, extractedName ] + let installPath = Path.concat [ tmp, formattedName ] + Log.debug $ "Installing " <> formattedName + Storage.download package version tarballPath + Run.liftAff do + Tar.extract { cwd: tmp, archive: tarballName } + FS.Extra.remove tarballPath + FS.Aff.rename extractedPath installPath + Log.debug $ "Installed " <> formatPackageVersion package version + Log.debug $ "Finding supported compiler versions for " <> formatPackageVersion package version - newManifests <- liftEffect $ Ref.read newManifestsRef - Log.info "here" - pure $ Solver.solve (map (map getDependencies) newManifests) (getDependencies manifest) + let + checkCompiler compiler = do + Log.debug $ "Trying to compile " <> formatPackageVersion package version <> " with purs@" <> Version.print compiler + + result <- Run.liftAff $ Purs.callCompiler + { command: Purs.Compile { globs: [ Path.concat [ formattedName, "src/**/*.purs" ] ] } + , version: Just (Version.print compiler) + , cwd: Just tmp + } - pure unit + case result of + Left _ -> do + Log.debug $ "Failed to compile " <> formatPackageVersion package version <> " with purs@" <> Version.print compiler + pure false + Right _ -> do + Log.debug $ "Compiled " <> formatPackageVersion package version <> " with purs@" <> Version.print compiler + pure true + + goCompilerVersions { first: mbFirst, last: mbLast } compilers = case Array.uncons compilers of + Nothing -> do -- no more compiler versions to check, construct range + case mbFirst, mbLast of + Just first, Just last -> pure $ Range.mk first (Version.bumpPatch last) + _, _ -> pure Nothing + Just { head, tail } -> do -- more compiler versions to check, may be done. + case mbFirst of + Nothing -> do -- searching for first compiler version + supported <- checkCompiler head + if supported then + goCompilerVersions { first: Just head, last: Just head } tail + else + goCompilerVersions { first: Nothing, last: Nothing } tail + Just first -> do -- already found first, need to check if contiguous compiler versions are valid + supported <- checkCompiler head + if supported then + goCompilerVersions { first: Just first, last: Just head } tail + else + goCompilerVersions { first: Just first, last: mbLast } [] + + mbRange <- goCompilerVersions { first: Nothing, last: Nothing } (Array.sort (NEA.toArray compilerVersions)) + case mbRange of + Nothing -> do + Log.error $ "Could not find supported compiler versions for " <> formatPackageVersion package version + Run.liftEffect $ Process.exit 1 + Just range -> + Log.info $ "Found supported compiler versions for " <> formatPackageVersion package version <> ": " <> Range.print range From bba9b3aace2f8b7232d0885a28c2b5a75d1e824f Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Thu, 20 Jul 2023 12:09:54 -0700 Subject: [PATCH 3/9] Format --- scripts/src/CompilerVersions.purs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index 7a9512d5..b0ac9840 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -36,7 +36,7 @@ import Registry.ManifestIndex as ManifestIndex import Registry.PackageName as PackageName import Registry.Range as Range import Registry.Version as Version -import Run (EFFECT, Run, AFF) +import Run (AFF, EFFECT, Run) import Run as Run import Run.Except (EXCEPT, rethrow, throw) import Run.Except as Except From 5fa0a3707fe5af945590e8613f769987ef75ec42 Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Thu, 20 Jul 2023 13:47:02 -0700 Subject: [PATCH 4/9] Add script --- scripts/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/default.nix b/scripts/default.nix index a275b7ec..5907c185 100644 --- a/scripts/default.nix +++ b/scripts/default.nix @@ -59,4 +59,5 @@ in { package-transferrer = build-script "registry-package-transferrer" "PackageTransferrer"; solver = build-script "registry-solver" "Solver"; verify-integrity = build-script "registry-verify-integrity" "VerifyIntegrity"; + compiler-versions = build-script "compiler-versions" "CompilerVersions"; } From 0d3ea1de90d3ea8702f2703144b5635690308526 Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Fri, 21 Jul 2023 09:20:01 -0700 Subject: [PATCH 5/9] Update scripts/default.nix Co-authored-by: Thomas Honeyman --- scripts/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/default.nix b/scripts/default.nix index 5907c185..17a2e839 100644 --- a/scripts/default.nix +++ b/scripts/default.nix @@ -59,5 +59,5 @@ in { package-transferrer = build-script "registry-package-transferrer" "PackageTransferrer"; solver = build-script "registry-solver" "Solver"; verify-integrity = build-script "registry-verify-integrity" "VerifyIntegrity"; - compiler-versions = build-script "compiler-versions" "CompilerVersions"; + compiler-versions = build-script "registry-compiler-versions" "CompilerVersions"; } From bfb6df283ee42e81effa2a8999fc519ca424d520 Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Fri, 21 Jul 2023 09:20:26 -0700 Subject: [PATCH 6/9] Generalize interpret --- scripts/src/CompilerVersions.purs | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index b0ac9840..e8e683af 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -115,19 +115,18 @@ main = launchAff_ do Console.log $ "Logs available at " <> logPath let - runDetermineCompilerVersionsForPackage :: PackageName -> Version -> Aff Unit - runDetermineCompilerVersionsForPackage package version = - determineCompilerVersionsForPackage package version - # Except.catch (\error -> Run.liftEffect (Console.log error *> Process.exit 1)) - # Registry.interpret (Registry.handle registryEnv) - # Storage.interpret (Storage.handleReadOnly cache) - # GitHub.interpret (GitHub.handle { octokit, cache, ref: githubCacheRef }) - # Log.interpret (\log -> Log.handleTerminal Normal log *> Log.handleFs Verbose logPath log) - # Run.runBaseAff' + interpret :: Run _ ~> Aff + interpret = + Except.catch (\error -> Run.liftEffect (Console.log error *> Process.exit 1)) + >>> Registry.interpret (Registry.handle registryEnv) + >>> Storage.interpret (Storage.handleReadOnly cache) + >>> GitHub.interpret (GitHub.handle { octokit, cache, ref: githubCacheRef }) + >>> Log.interpret (\log -> Log.handleTerminal Normal log *> Log.handleFs Verbose logPath log) + >>> Run.runBaseAff' case arguments of File _ -> Console.log "Unsupported at this time." *> liftEffect (Process.exit 1) - Package package version -> runDetermineCompilerVersionsForPackage package version + Package package version -> interpret $ determineCompilerVersionsForPackage package version AllPackages -> Console.log "Unsupported at this time." *> liftEffect (Process.exit 1) determineCompilerVersionsForPackage :: forall r. PackageName -> Version -> Run (AFF + EFFECT + REGISTRY + EXCEPT String + LOG + STORAGE + r) Unit From 9b79ef877fd0574ad3a42c0f10270133b7ea177d Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Fri, 21 Jul 2023 09:33:34 -0700 Subject: [PATCH 7/9] Argument help cleanup --- scripts/src/CompilerVersions.purs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index e8e683af..2562f892 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -49,14 +49,14 @@ data InputMode parser :: ArgParser InputMode parser = Arg.choose "input (--file or --package or --all)" [ Arg.argument [ "--file" ] - """Verify packages from a JSON file like: [ "prelude", "console" ]""" + """Compute supported compiler versions for packages from a JSON file like: [ "prelude", "console" ]""" # Arg.unformat "FILE_PATH" pure # map File , Arg.argument [ "--package" ] - "Verify the indicated package" + "Compute supported compiler versions for the indicated package" # Arg.unformat "NAME@VERSION" parsePackage # map (uncurry Package) - , Arg.flag [ "--all" ] "Verify all packages" $> AllPackages + , Arg.flag [ "--all" ] "Compute supported compiler versions for all packages" $> AllPackages ] where parsePackage :: String -> Either String (Tuple PackageName Version) From 842cb6fae6d6a07d0b482b0d1ce123988fe1a8d4 Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Fri, 21 Jul 2023 09:34:31 -0700 Subject: [PATCH 8/9] Qualified rethrow/throw --- scripts/src/CompilerVersions.purs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index 2562f892..026c4483 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -38,7 +38,7 @@ import Registry.Range as Range import Registry.Version as Version import Run (AFF, EFFECT, Run) import Run as Run -import Run.Except (EXCEPT, rethrow, throw) +import Run.Except (EXCEPT) import Run.Except as Except data InputMode @@ -134,10 +134,10 @@ determineCompilerVersionsForPackage package version = do allManifests <- map ManifestIndex.toMap Registry.readAllManifests compilerVersions <- PursVersions.pursVersions Log.debug $ "Checking Manifest Index for " <> formatPackageVersion package version - Manifest { dependencies } <- rethrow $ (note "Invalid Version" <<< Map.lookup version <=< note "Invalid PackageName" <<< Map.lookup package) allManifests + Manifest { dependencies } <- Except.rethrow $ (note "Invalid Version" <<< Map.lookup version <=< note "Invalid PackageName" <<< Map.lookup package) allManifests unless (Map.isEmpty dependencies) do Log.error "Cannot check package that has dependencies." - throw "Cannot check package that has dependencies." + Except.throw "Cannot check package that has dependencies." tmp <- Run.liftAff Tmp.mkTmpDir let formattedName = formatPackageVersion package version let extractedName = PackageName.print package <> "-" <> Version.print version From 639464f82e1a93fb108e1df45ea388a44404e89a Mon Sep 17 00:00:00 2001 From: Colin Wahl <8431409+colinwahl@users.noreply.github.com> Date: Fri, 21 Jul 2023 15:02:30 -0700 Subject: [PATCH 9/9] Compute all supported compiler versions --- scripts/src/CompilerVersions.purs | 44 ++++++++++++------------------- 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/scripts/src/CompilerVersions.purs b/scripts/src/CompilerVersions.purs index 026c4483..a6dbcb26 100644 --- a/scripts/src/CompilerVersions.purs +++ b/scripts/src/CompilerVersions.purs @@ -7,6 +7,7 @@ import ArgParse.Basic as Arg import Data.Array as Array import Data.Array.NonEmpty as NEA import Data.Formatter.DateTime as Formatter.DateTime +import Data.List (filterM) import Data.Map as Map import Data.String as String import Data.Tuple (uncurry) @@ -172,30 +173,19 @@ determineCompilerVersionsForPackage package version = do Log.debug $ "Compiled " <> formatPackageVersion package version <> " with purs@" <> Version.print compiler pure true - goCompilerVersions { first: mbFirst, last: mbLast } compilers = case Array.uncons compilers of - Nothing -> do -- no more compiler versions to check, construct range - case mbFirst, mbLast of - Just first, Just last -> pure $ Range.mk first (Version.bumpPatch last) - _, _ -> pure Nothing - Just { head, tail } -> do -- more compiler versions to check, may be done. - case mbFirst of - Nothing -> do -- searching for first compiler version - supported <- checkCompiler head - if supported then - goCompilerVersions { first: Just head, last: Just head } tail - else - goCompilerVersions { first: Nothing, last: Nothing } tail - Just first -> do -- already found first, need to check if contiguous compiler versions are valid - supported <- checkCompiler head - if supported then - goCompilerVersions { first: Just first, last: Just head } tail - else - goCompilerVersions { first: Just first, last: mbLast } [] - - mbRange <- goCompilerVersions { first: Nothing, last: Nothing } (Array.sort (NEA.toArray compilerVersions)) - case mbRange of - Nothing -> do - Log.error $ "Could not find supported compiler versions for " <> formatPackageVersion package version - Run.liftEffect $ Process.exit 1 - Just range -> - Log.info $ "Found supported compiler versions for " <> formatPackageVersion package version <> ": " <> Range.print range + goCompilerVersions supported compilers = case Array.uncons compilers of + Nothing -> pure supported + Just { head, tail } -> do + success <- checkCompiler head + if success then + goCompilerVersions (supported <> [ head ]) tail + else + goCompilerVersions supported tail + + supported <- goCompilerVersions [] (Array.sort (NEA.toArray compilerVersions)) + + if Array.null supported then do + Log.error $ "Could not find supported compiler versions for " <> formatPackageVersion package version + Run.liftEffect $ Process.exit 1 + else + Log.info $ "Found supported compiler versions for " <> formatPackageVersion package version <> ": " <> Array.intercalate ", " (map Version.print supported)