Detect yml instead of yaml (purescript#1155)

---------

Co-authored-by: Jordan Martinez <[email protected]>

Author: flip111

core/src/Config.purs

@@ -47,6 +47,8 @@ import Data.Either as Either
 import Data.List as List
 import Data.Map as Map
 import Data.Profunctor as Profunctor
+import Data.String (stripSuffix) as String
+import Data.String.Pattern (Pattern(..)) as String
 import Partial.Unsafe (unsafeCrashWith)
 import Registry.Internal.Codec as Internal.Codec
 import Registry.License as License
@@ -477,11 +479,30 @@ legacyPackageSetEntryCodec = CA.object "LegacyPackageSetEntry"
   $ CA.recordProp (Proxy :: _ "dependencies") (CA.array PackageName.codec)
   $ CA.record
 
-readConfig :: forall a. FilePath -> Spago (LogEnv a) (Either String { doc :: YamlDoc Config, yaml :: Config })
+readConfig :: forall a. FilePath -> Spago (LogEnv a) (Either (Array String) { doc :: YamlDoc Config, yaml :: Config })
 readConfig path = do
   logDebug $ "Reading config from " <> path
   FS.exists path >>= case _ of
-    false -> pure $ Left $ case path of
-      "spago.yaml" -> "Did not find " <> path <> " Run `spago init` to initialise a new project."
-      _ -> "Did not find " <> path
-    true -> liftAff $ FS.readYamlDocFile configCodec path
+    false -> do
+      let replaceExt = map (_ <> ".yml") <<< String.stripSuffix (String.Pattern ".yaml")
+      yml <- map join $ for (replaceExt path) \yml -> do
+        hasYml <- FS.exists yml
+        pure $
+          if hasYml then
+            Just yml
+          else
+            Nothing
+      pure $ Left $ case path, yml of
+        "spago.yaml", Nothing ->
+          [ "Did not find `" <> path <> "`. Run `spago init` to initialize a new project." ]
+        "spago.yaml", Just y ->
+          [ "Did not find `" <> path <> "`. Spago's configuration files must end with `.yaml`, not `.yml`. "
+          , "Try renaming `" <> y <> "` to `" <> path <> "` or run `spago init` to initialize a new project."
+          ]
+        _, Nothing ->
+          [ "Did not find `" <> path <> "`." ]
+        _, Just y ->
+          [ "Did not find `" <> path <> "`. Spago's configuration files must end with `.yaml`, not `.yml`. "
+          , "Try renaming `" <> y <> "` to `" <> path <> "`."
+          ]
+    true -> liftAff $ map (lmap pure) $ FS.readYamlDocFile configCodec path

src/Spago/Command/Fetch.purs

@@ -377,7 +377,11 @@ getPackageDependencies packageName package = case package of
       Right { yaml: { package: Just { dependencies: (Dependencies deps) } } } -> do
         pure (Just (map (fromMaybe Config.widestRange) deps))
       Right _ -> die [ "Read valid configuration from " <> configLocation, "However, there was no `package` section to be read." ]
-      Left err -> die [ "Could not read config at " <> configLocation, "Error: " <> err ]
+      Left errLines -> die
+        [ toDoc $ "Could not read config at " <> configLocation
+        , toDoc "Error: "
+        , indent $ toDoc errLines
+        ]
 
 getWorkspacePackageDeps :: WorkspacePackage -> Dependencies
 getWorkspacePackageDeps pkg =

src/Spago/Config.purs

@@ -155,7 +155,12 @@ readWorkspace { maybeSelectedPackage, pureBuild } = do
   -- First try to read the config in the root. It _has_ to contain a workspace
   -- configuration, or we fail early.
   { workspace, package: maybePackage, workspaceDoc } <- Core.readConfig "spago.yaml" >>= case _ of
-    Left err -> die [ "Couldn't parse Spago config, error:\n  " <> err, "The configuration file help can be found here https://github.com/purescript/spago#the-configuration-file" ]
+    Left errLines ->
+      die
+        [ toDoc "Couldn't parse Spago config, error:"
+        , indent $ toDoc errLines
+        , toDoc "The configuration file help can be found here https://github.com/purescript/spago#the-configuration-file"
+        ]
     Right { yaml: { workspace: Nothing } } -> die
       [ "Your spago.yaml doesn't contain a workspace section."
       , "See the relevant documentation here: https://github.com/purescript/spago#the-workspace"
@@ -188,15 +193,19 @@ readWorkspace { maybeSelectedPackage, pureBuild } = do
       -- We try to figure out if this package has tests - look for test sources
       hasTests <- FS.exists (Path.concat [ Path.dirname path, "test" ])
       pure $ case maybeConfig of
-        Left e -> Left $ "Could not read config at path " <> path <> "\nError was: " <> e
-        Right { yaml: { package: Nothing } } -> Left $ "No package found for config at path: " <> path
+        Left eLines -> Left $ toDoc
+          [ toDoc $ "Could not read config at path " <> path
+          , toDoc "Error was: "
+          , indent $ toDoc eLines
+          ]
+        Right { yaml: { package: Nothing } } -> Left $ toDoc $ "No package found for config at path: " <> path
         Right { yaml: { package: Just package, workspace: configWorkspace }, doc } -> do
           -- We store the path of the package, so we can treat it basically as a LocalPackage
           Right $ Tuple package.name { path: Path.dirname path, package, configWorkspace, doc, hasTests }
   { right: otherPackages, left: failedPackages } <- partitionMap identity <$> traverse readWorkspaceConfig otherConfigPaths
 
   unless (Array.null failedPackages) do
-    logWarn $ [ "Failed to read some configs:" ] <> failedPackages
+    logWarn $ [ toDoc "Failed to read some configs:" ] <> failedPackages
 
   -- We prune any configs that use a different workspace.
   -- For reasoning, see https://github.com/purescript/spago/issues/951

test-fixtures/spago-yml-check-stderr.txt

@@ -0,0 +1,6 @@
+Reading Spago workspace configuration...
+
+❌ Couldn't parse Spago config, error:
+  Did not find `spago.yaml`. Spago's configuration files must end with `.yaml`, not `.yml`. 
+  Try renaming `spago.yml` to `spago.yaml` or run `spago init` to initialize a new project.
+The configuration file help can be found here https://github.com/purescript/spago#the-configuration-file

test/Spago/Test.purs

@@ -138,3 +138,7 @@ spec = Spec.around withTempDir do
             Assert.fail $ "STDERR did not contain text:\n" <> exp <> "\n\nStderr was:\n" <> stdErr
       spago [ "test" ] >>= check { stdout: mempty, stderr: hasUnusedNameWarningError, result: isRight }
 
+    Spec.it "check for spago.yml" \{ spago, fixture } -> do
+      spago [ "init", "--name", "aaa" ] >>= shouldBeSuccess
+      FS.moveSync {src: "spago.yaml", dst: "spago.yml"}
+      spago [ "build" ] >>= shouldBeFailureErr (fixture "spago-yml-check-stderr.txt")