Allow to freely intermix GHC flags and Hspec options on the command-line

Don't accept Hspec's `-f <formatter>`, as it collides with GHC flags.
Instead, `--format <formatter>` can be used.

Author: sol

README.md

@@ -12,13 +12,17 @@ additional GHC options on the command line:
 
     sensei -isrc -itest test/Spec.hs
 
-Command-line arguments that look like Hspec options are passed to Hspec.  To
-avoid ambiguity, GHC options have to be given before any Hspec options:
+Command-line arguments that look like Hspec options are passed to Hspec:
 
     sensei -isrc -itest test/Spec.hs --no-color --match foo
 
-All command-line arguments after the last `--` are passed to Hspec, regardless
-of how they look:
+Hspec's `-f` option collides with GHC flags.  To avoid ambiguity, `sensei` does
+not accept Hspec's `-f` option.  Use `--format` instead:
+
+    sensei -isrc -itest test/Spec.hs --format progress -fdiagnostics-as-json
+
+A `--` disables any command-line processing.  All command-line arguments after
+the last `--` are unconditionally passed to Hspec:
 
     sensei -isrc -itest test/Spec.hs -- --no-color --match foo
 

src/Options.hs

@@ -1,23 +1,46 @@
 module Options (splitArgs) where
 
 import           Imports
+import           Data.Coerce (coerce)
+import qualified GHC.List as List
 
 import           System.Console.GetOpt
 
 splitArgs :: [String] -> ([String], [String])
 splitArgs args = case break (== "--") $ reverse args of
   (xs, "--" : ys) -> (reverse ys, reverse xs)
-  _ -> case filter isHspecArgs $ tails args of
-    x : _ -> (dropEnd (length x) args, x)
-    [] -> (args, [])
-  where
-    isHspecArgs :: [String] -> Bool
-    isHspecArgs xs = case getOpt Permute options xs of
-      (result, [], []) -> all (== Valid) result
-      _ -> False
+  _ -> partitionOptions $ classify args
+
+newtype GhcOption = GhcOption [String]
+newtype HspecOption = HspecOption [String]
+
+type Option = Either GhcOption HspecOption
+
+ghcOption :: [String] -> Option
+ghcOption = Left . GhcOption
+
+hspecOption :: [String] -> Option
+hspecOption = Right . HspecOption
+
+partitionOptions :: [Option] -> ([String], [String])
+partitionOptions = bimap (List.concat . coerce) (List.concat . coerce) . partitionEithers
+
+classify :: [String] -> [Option]
+classify = takeHspec >>> \ case
+  ([], []) -> []
+  ([], ghc : args) -> ghcOption [ghc] : classify args
+  (hspec, args) -> hspecOption hspec : classify args
+
+takeHspec :: [String] -> ([String], [String])
+takeHspec = \ case
+  a : args | isHspecArgs [a] -> ([a], args)
+  a : b : args | isHspecArgs [a, b] -> ([a, b], args)
+  args -> ([], args)
 
-    dropEnd :: Int -> [a] -> [a]
-    dropEnd n = reverse . drop n . reverse
+isHspecArgs :: [String] -> Bool
+isHspecArgs xs = case getOpt Permute options xs of
+  (result, [], []) -> all (== Valid) result
+  _ -> False
 
 data Valid = Valid | Invalid
   deriving (Eq, Show)
@@ -52,7 +75,7 @@ options = concat [
   , reqArg "" "seed" "N"
   , reqArg "" "skip" "PATTERN"
   , reqArg "a" "qc-max-success" "N"
-  , reqArg "f" "format" "NAME"
+  , reqArg "" "format" "NAME"
   , reqArg "m" "match" "PATTERN"
   , [Option "p" ["print-slow-items"] (OptArg (maybe Valid intArg) "N") ""]
   ]

test/Language/Haskell/GhciWrapperSpec.hs

@@ -1,5 +1,5 @@
 {-# LANGUAGE CPP #-}
-module Language.Haskell.GhciWrapperSpec (main, spec) where
+module Language.Haskell.GhciWrapperSpec (spec) where
 
 import           Helper hiding (diagnostic, ghciConfig)
 import qualified Helper
@@ -9,9 +9,6 @@ import qualified Data.ByteString.Char8 as ByteString
 import           Language.Haskell.GhciWrapper (Config(..), Interpreter(..), ReloadStatus(..), Extract(..))
 import qualified Language.Haskell.GhciWrapper as Interpreter
 
-main :: IO ()
-main = hspec spec
-
 withInterpreter :: [String] -> (Interpreter -> IO a) -> IO a
 withInterpreter args action = do
   c <- Helper.ghciConfig

test/OptionsSpec.hs

@@ -1,27 +1,29 @@
-module OptionsSpec (main, spec) where
+module OptionsSpec (spec) where
 
 import           Helper
 
 import           Options
 
-main :: IO ()
-main = hspec spec
-
 spec :: Spec
 spec = do
-  describe "splitArgs" $ do
-    it "returns longest matching list of Hspec options from end of given list" $ do
-      splitArgs ["foo", "--bar", "-m", "FooSpec", "-a", "1000"] `shouldBe` (["foo", "--bar"], ["-m", "FooSpec", "-a", "1000"])
+  describe "splitArgs" do
+    it "passes command-line arguments that look like Hspec options to Hspec" do
+      splitArgs ["foo", "-m", "FooSpec", "--bar", "-a", "1000"] `shouldBe`
+        (["foo", "--bar"], ["-m", "FooSpec", "-a", "1000"])
+
+    it "passes -f options to GHC" do
+      splitArgs ["--format", "checks", "-fno-diagnostics-as-json"] `shouldBe`
+        (["-fno-diagnostics-as-json"], ["--format", "checks"])
 
-    it "assumes everything after the last '--' to be Hspec options" $ do
+    it "assumes everything after the last '--' to be Hspec options" do
       splitArgs ["foo", "bar", "--", "foo", "baz"] `shouldBe` (["foo", "bar"], ["foo", "baz"])
 
-    context "with -p" $ do
-      it "recognizes -p as an Hspec option" $ do
+    context "with -p" do
+      it "recognizes -p as an Hspec option" do
         splitArgs ["-p"] `shouldBe` ([], ["-p"])
 
-      it "recognizes -pN as an Hspec option" $ do
+      it "recognizes -pN as an Hspec option" do
         splitArgs ["-p20"] `shouldBe` ([], ["-p20"])
 
-      it "recognizes -packageNAME as a GHC option" $ do
+      it "recognizes -packageNAME as a GHC option" do
         splitArgs ["-packagebase"] `shouldBe` (["-packagebase"], [])