@@ -85,11 +85,11 @@ initForce = switch (long "force" <> help "Allow ob init to overwrite files")
8585data ObCommand
8686 = ObCommand_Init InitSource Bool
8787 | ObCommand_Deploy DeployCommand
88− | ObCommand_Run [(FilePath, HackOn)]
88+ | ObCommand_Run [(FilePath, Interpret)]
8989 | ObCommand_Profile String [String]
9090 | ObCommand_Thunk ThunkOption
91− | ObCommand_Repl [(FilePath, HackOn)]
92− | ObCommand_Watch [(FilePath, HackOn)]
91+ | ObCommand_Repl [(FilePath, Interpret)]
92+ | ObCommand_Watch [(FilePath, Interpret)]
9393 | ObCommand_Shell ShellOpts
9494 | ObCommand_Doc String [String] -- shell and list of packages
9595 | ObCommand_Hoogle String Int -- shell and port
@@ -100,7 +100,7 @@ data ObInternal
100100 -- the preprocessor argument syntax is also handled outside
101101 -- optparse-applicative, but it shouldn't ever conflict with another syntax
102102 = ObInternal_ApplyPackages String String String [String]
103− | ObInternal_ExportGhciConfig [(FilePath, HackOn)]
103+ | ObInternal_ExportGhciConfig [(FilePath, Interpret)]
104104 deriving Show
105105
106106obCommand :: ArgsConfig -> Parser ObCommand
@@ -108,11 +108,11 @@ obCommand cfg = hsubparser
108108 (mconcat
109109 [ command "init" $ info (ObCommand_Init <$> initSource <*> initForce) $ progDesc "Initialize an Obelisk project"
110110 , command "deploy" $ info (ObCommand_Deploy <$> deployCommand cfg) $ progDesc "Prepare a deployment for an Obelisk project"
111− , command "run" $ info (ObCommand_Run <$> hackOnOpts) $ progDesc "Run current project in development mode"
111+ , command "run" $ info (ObCommand_Run <$> interpretOpts) $ progDesc "Run current project in development mode"
112112 , command "profile" $ info (uncurry ObCommand_Profile <$> profileCommand) $ progDesc "Run current project with profiling enabled"
113113 , command "thunk" $ info (ObCommand_Thunk <$> thunkOption) $ progDesc "Manipulate thunk directories"
114− , command "repl" $ info (ObCommand_Repl <$> hackOnOpts) $ progDesc "Open an interactive interpreter"
115− , command "watch" $ info (ObCommand_Watch <$> hackOnOpts) $ progDesc "Watch current project for errors and warnings"
114+ , command "repl" $ info (ObCommand_Repl <$> interpretOpts) $ progDesc "Open an interactive interpreter"
115+ , command "watch" $ info (ObCommand_Watch <$> interpretOpts) $ progDesc "Watch current project for errors and warnings"
116116 , command "shell" $ info (ObCommand_Shell <$> shellOpts) $ progDesc "Enter a shell with project dependencies"
117117 , command "doc" $ info (ObCommand_Doc <$> shellFlags <*> packageNames) $
118118 progDesc "List paths to haddock documentation for specified packages"
@@ -125,7 +125,7 @@ obCommand cfg = hsubparser
125125
126126internalCommand :: Parser ObInternal
127127internalCommand = hsubparser $ mconcat
128− [ command "export-ghci-configuration" $ info (ObInternal_ExportGhciConfig <$> hackOnOpts) $ progDesc "Export the GHCi configuration used by ob run, etc.; useful for IDE integration"
128+ [ command "export-ghci-configuration" $ info (ObInternal_ExportGhciConfig <$> interpretOpts) $ progDesc "Export the GHCi configuration used by ob run, etc.; useful for IDE integration"
129129 ]
130130
131131packageNames :: Parser [String]
@@ -258,7 +258,7 @@ thunkOption = hsubparser $ mconcat
258258data ShellOpts
259259 = ShellOpts
260260 { _shellOpts_shell :: String
261− , _shellOpts_hackPaths :: [(FilePath, HackOn)]
261+ , _shellOpts_interpretPaths :: [(FilePath, Interpret)]
262262 , _shellOpts_command :: Maybe String
263263 }
264264 deriving Show
@@ -269,18 +269,21 @@ shellFlags =
269269 <|> flag "ghc" "ghcjs" (long "ghcjs" <> help "Enter a shell having ghcjs rather than ghc")
270270 <|> strOption (short 'A' <> long "argument" <> metavar "NIXARG" <> help "Use the environment specified by the given nix argument of `shells'")
271271
272−hackOnOpts :: Parser [(FilePath, HackOn)]
273−hackOnOpts = many
274− ( (, HackOn_HackOn) <$>
275− strOption (common <> long "hack-on" <> help
272+interpretOpts :: Parser [(FilePath, Interpret)]
273+interpretOpts = many
274+ ( (, Interpret_Interpret) <$>
275+ strOption (common <> long "interpret" <> help
276276 "Don't pre-build packages found in DIR when constructing the package database. The default behavior is \
277− \'--hack-on <project-root>'. Use --hack-on and --no-hack-on multiple times to add or remove multiple trees \
278− \ from the environment. Right-most directories will override directories on the left in as much as they overlap."
277+ \'--interpret <project-root>', which will load everything which is unpacked into GHCi. \
278+ \ Use --interpret and --no-interpret multiple times to add or remove multiple trees \
279+ \ from the environment. Settings for right-most directories will \
280+ \ override settings for any identical directories given earlier."
279281 )
280− <|> (, HackOn_NoHackOn) <$>
281− strOption (common <> long "no-hack-on" <> help
282+ <|> (, Interpret_NoInterpret) <$>
283+ strOption (common <> long "no-interpret" <> help
282284 "Make packages found in DIR available in the package database (but only when they are used dependencies). \
283− \See help for --hack-on for how the two options are related."
285+ \ This will build the packages in DIR before loading GHCi. \
286+ \See help for ---on for how the two options are related."
284287 )
285288 )
286289 where
@@ -289,7 +292,7 @@ hackOnOpts = many
289292shellOpts :: Parser ShellOpts
290293shellOpts = ShellOpts
291294 <$> shellFlags
292− <*> hackOnOpts
295+ <*> interpretOpts
293296 <*> optional (strArgument (metavar "COMMAND"))
294297
295298portOpt :: Int -> Parser Int
@@ -407,7 +410,7 @@ ob = \case
407410 Just RemoteBuilder_ObeliskVM -> (:[]) <$> VmBuilder.getNixBuildersArg
408411 DeployCommand_Update -> deployUpdate "."
409412 DeployCommand_Test (platform, extraArgs) -> deployMobile platform extraArgs
410− ObCommand_Run hackPathsList -> withHackPaths hackPathsList run
413+ ObCommand_Run interpretPathsList -> withInterpretPaths interpretPathsList run
411414 ObCommand_Profile basePath rtsFlags -> profile basePath rtsFlags
412415 ObCommand_Thunk to -> case _thunkOption_command to of
413416 ThunkCommand_Update config -> for_ thunks (updateThunkToLatest config)
@@ -416,27 +419,27 @@ ob = \case
416419 ThunkCommand_Init -> for_ thunks initThunk
417420 where
418421 thunks = _thunkOption_thunks to
419− ObCommand_Repl hackPathsList -> withHackPaths hackPathsList runRepl
420− ObCommand_Watch hackPathsList -> withHackPaths hackPathsList runWatch
421− ObCommand_Shell (ShellOpts shellAttr hackPathsList cmd) -> withHackPaths hackPathsList $ \root hackPaths ->
422− nixShellForHackPaths False shellAttr root hackPaths cmd
422+ ObCommand_Repl interpretPathsList -> withInterpretPaths interpretPathsList runRepl
423+ ObCommand_Watch interpretPathsList -> withInterpretPaths interpretPathsList runWatch
424+ ObCommand_Shell (ShellOpts shellAttr interpretPathsList cmd) -> withInterpretPaths interpretPathsList $ \root interpretPaths ->
425+ nixShellForInterpretPaths False shellAttr root interpretPaths cmd
423426 ObCommand_Doc shellAttr pkgs -> withProjectRoot "." $ \root ->
424− nixShellForHackPaths True shellAttr root emptyPathTree $ Just $ haddockCommand pkgs
427+ nixShellForInterpretPaths True shellAttr root emptyPathTree $ Just $ haddockCommand pkgs
425428 ObCommand_Hoogle shell' port -> withProjectRoot "." $ \root -> do
426429 nixShellWithHoogle root True shell' $ Just $ "hoogle server -p " <> show port <> " --local"
427430 ObCommand_Internal icmd -> case icmd of
428431 ObInternal_ApplyPackages origPath inPath outPath packagePaths -> do
429432 liftIO $ Preprocessor.applyPackages origPath inPath outPath packagePaths
430− ObInternal_ExportGhciConfig hackPathsList -> liftIO . putStrLn . unlines =<< withHackPaths hackPathsList exportGhciConfig
433+ ObInternal_ExportGhciConfig interpretPathsList -> liftIO . putStrLn . unlines =<< withInterpretPaths interpretPathsList exportGhciConfig
431434
432435-- | A helper for the common case that the command you want to run needs the project root and a resolved
433−-- set of hacking paths.
434−withHackPaths :: MonadObelisk m => [(FilePath, HackOn)] -> (FilePath -> PathTree HackOn -> m a) -> m a
435−withHackPaths hackPathsList f = withProjectRoot "." $ \root -> do
436− hackPaths' <- resolveHackPaths $ (root, HackOn_HackOn) : hackPathsList
437− case hackPaths' of
436+-- set of interpret paths.
437+withInterpretPaths :: MonadObelisk m => [(FilePath, Interpret)] -> (FilePath -> PathTree Interpret -> m a) -> m a
438+withInterpretPaths interpretPathsList f = withProjectRoot "." $ \root -> do
439+ interpretPaths' <- resolveInterpretPaths $ (root, Interpret_Interpret) : interpretPathsList
440+ case interpretPaths' of
438441 Nothing -> failWith "No paths provided for finding packages"
439− Just hackPaths -> f root hackPaths
442+ Just interpretPaths -> f root interpretPaths
440443
441444haddockCommand :: [String] -> String
442445haddockCommand pkgs = unwords
@@ -451,25 +454,21 @@ haddockCommand pkgs = unwords
451454getArgsConfig :: IO ArgsConfig
452455getArgsConfig = pure $ ArgsConfig { _argsConfig_enableVmBuilderByDefault = System.Info.os == "darwin" }
453456
454−
455−-- | Resolves an ordered list of paths for use with @--hack-on@/@--no-hack-on@ by coalescing
457+-- | Resolves an ordered list of paths for use with @--interpret@/@--no-interpret@ by coalescing
456458-- paths into a non-ambiguous set of paths. Ambiguity is resolved by chosing right-most paths
457−-- over any preceeding paths where they overlap.
459+-- over any preceeding identical paths.
458460--
459−-- For example: @a/b=ON a/b/c=OFF@ produces @a/b=ON a/b/c=OFF@ (the same value) but flipping
460−-- the order does not as @a/b/c=OFF a/b=ON@ produces @a/b=ON@ since @a/b/c@ is inside @a/b@ and
461−-- @a/b@ is the right-most.
461+-- For example: @a/b=ON a/b/c=OFF@ and @a/b/c=OFF a/b=ON@ are the same.
462+-- @a/b=ON a/b=OFF@ is reduced to @a/b=OFF@. We prefer right-biased choice to
463+-- increase scriptability.
462464--
463465-- N.B. All the paths in the result will be canonicalized. It's impossible to determine path
464466-- overlap otherwise.
465−resolveHackPaths :: MonadIO m => [(FilePath, a)] -> m (Maybe (PathTree a))
466−resolveHackPaths ps = do
467+resolveInterpretPaths :: MonadIO m => [(FilePath, a)] -> m (Maybe (PathTree a))
468+resolveInterpretPaths ps = do
467469 trees <- liftIO $ for ps $ \(p, a) -> pathToTree a <$> canonicalizePath p
468− pure $ foldr1 mergeRightBias <$> nonEmpty trees
470+ pure $ foldr1 mergeTrees <$> nonEmpty trees
469471 where
470472 -- | Merge two 'PathTree's preferring leaves on the right in as much as they overlap with paths on the left.
471− mergeRightBias :: PathTree a -> PathTree a -> PathTree a
472− mergeRightBias = go
473− where
474− go _ b@(PathTree_Node (Just _) _) = b -- When a leaf is present on the right, right always wins.
475− go (PathTree_Node v a) (PathTree_Node Nothing b) = PathTree_Node v $ Map.unionWith go a b
473+ mergeTrees :: PathTree a -> PathTree a -> PathTree a
474+ mergeTrees (PathTree_Node ax x) (PathTree_Node ay y) = PathTree_Node (ay <|> ax) $ Map.unionWith mergeTrees x y