darcs 2.16.1 → 2.16.2
raw patch · 9 files changed
+30/−1446 lines, 9 filesdep +exceptionsdep +monad-controldep +system-fileiodep −shellydep ~asyncdep ~processdep ~timePVP ok
version bump matches the API change (PVP)
Dependencies added: exceptions, monad-control, system-fileio, system-filepath, transformers-base
Dependencies removed: shelly
Dependency ranges changed: async, process, time, unix-compat
API changes (from Hackage documentation)
Files
- CHANGELOG +10/−0
- darcs.cabal +17/−7
- release/distributed-context +1/−1
- shelly/shelly.cabal +0/−198
- shelly/src/Shelly.hs +1/−1
- shelly/src/Shelly/Find.hs +1/−0
- shelly/src/Shelly/Lifted.hs +0/−584
- shelly/src/Shelly/Pipe.hs +0/−643
- shelly/src/Shelly/Unix.hs +0/−12
CHANGELOG view
@@ -1,3 +1,13 @@+Darcs 2.16.2, 19 August 2020++ * Fix build problem when using 'cabal install' from inside the sdist.++ This fails because in this case cabal will try to 'cabal sdist' the+ bundled shelly dependency, and we do not (nor want to) list all shelly+ files in our own cabal file. To avoid problems like this, we no longer+ use the bundled shelly as a dependency, but rather as part of our+ sources for the test suite.+ Darcs 2.16.1, 14 August 2020 * Building:
darcs.cabal view
@@ -1,6 +1,6 @@ Cabal-Version: 2.2 Name: darcs-version: 2.16.1+version: 2.16.2 License: GPL-2.0-or-later License-file: COPYING Author: David Roundy <droundy@darcs.net>, <darcs-devel@darcs.net>@@ -64,9 +64,6 @@ -- bundled shelly (the bare minimum required) shelly/LICENSE- shelly/shelly.cabal- shelly/src/Shelly/*.hs- shelly/src/Shelly.hs -- testsuite tests/data/*.tgz@@ -561,7 +558,7 @@ type: exitcode-stdio-1.0 default-language: Haskell2010 main-is: test.hs- hs-source-dirs: harness+ hs-source-dirs: harness, shelly/src if os(windows) cpp-options: -DWIN32@@ -577,7 +574,6 @@ filepath, mtl, transformers,- shelly >= 1.6.8 && < 1.10, split >= 0.2.2 && < 0.3, text, directory,@@ -590,7 +586,18 @@ test-framework-quickcheck2 >= 0.3.0.3 && < 0.4, test-framework-leancheck >= 0.0.1 && < 0.1, vector,- zip-archive+ zip-archive,+ -- additional dependencies needed by the shelly modules+ async,+ directory,+ exceptions >= 0.6,+ monad-control >= 0.3.2 && < 1.1,+ process,+ system-filepath >= 0.4.7 && < 0.5,+ system-fileio < 0.4,+ time,+ transformers-base,+ unix-compat, -- the tests shell out to a built darcs binary, so we depend on it to make -- sure that it's built. It's not actually required for build, just at runtime,@@ -647,6 +654,9 @@ Darcs.Test.TestOnly.Instance Darcs.Test.Util.TestResult Darcs.Test.Util.QuickCheck+ Shelly+ Shelly.Base+ Shelly.Find if flag(warn-as-error) ghc-options: -Werror
release/distributed-context view
@@ -1,1 +1,1 @@-Just "\nContext:\n\n\n[TAG 2.16.1\nBen Franksen <ben.franksen@online.de>**20200814093257\n Ignore-this: b5957de98ad629b97483fd6bee8941e2871a58aac4c559d37921feda3e88f06c5a939f40820abf9f\n] \n"+Just "\nContext:\n\n\n[TAG 2.16.2\nBen Franksen <ben.franksen@online.de>**20200819210622\n Ignore-this: 8aeca92b4f3d72a38b97ea681f4f87ea9f13e1a0abb37954596cbc64754cdaf4202fe95d848e9764\n] \n"
− shelly/shelly.cabal
@@ -1,198 +0,0 @@-Name: shelly--Version: 1.7.1.1-Synopsis: shell-like (systems) programming in Haskell--Description: Shelly provides convenient systems programming in Haskell,- similar in spirit to POSIX shells. Shelly:- .- * is aimed at convenience and getting things done rather than- being a demonstration of elegance.- .- * has detailed and useful error messages- .- * maintains its own environment, making it thread-safe.- .- * is modern, using Text and system-filepath/system-fileio- .- Shelly is originally forked from the Shellish package.- .- See the shelly-extra package for additional functionality.- .- An overview is available in the README: <https://github.com/yesodweb/Shelly.hs/blob/master/README.md>---Homepage: https://github.com/yesodweb/Shelly.hs-License: BSD3-License-file: LICENSE-Author: Greg Weber, Petr Rockai-Maintainer: Greg Weber <greg@gregweber.info>-Category: Development-Build-type: Simple-Cabal-version: >=1.8---- for the sdist of the test suite-extra-source-files: test/src/*.hs- test/examples/*.sh- test/examples/*.hs- test/data/zshrc- test/data/nonascii.txt- test/data/symlinked_dir/hoge_file- test/testall- README.md- ChangeLog.md--Library- Exposed-modules: Shelly, Shelly.Lifted, Shelly.Pipe, Shelly.Unix- other-modules: Shelly.Base, Shelly.Find- hs-source-dirs: src- other-extensions: InstanceSigs-- Build-depends:- containers >= 0.4.2.0,- time >= 1.3 && < 2,- directory >= 1.1.0.0 && < 1.4.0.0,- mtl >= 2,- process >= 1.0,- unix-compat < 0.6,- system-filepath >= 0.4.7 && < 0.5,- system-fileio < 0.4,- monad-control >= 0.3.2 && < 1.1,- lifted-base,- lifted-async,- exceptions >= 0.6,- enclosed-exceptions,- text, bytestring, async, transformers, transformers-base-- if impl(ghc >= 7.6.1)- build-depends:- base >= 4.6 && < 5- else- build-depends:- base >= 4 && < 5-- ghc-options: -Wall-- if impl(ghc >= 7.6.1)- CPP-Options: -DNO_PRELUDE_CATCH-- extensions:- CPP--source-repository head- type: git- location: https://github.com/yesodweb/Shelly.hs--Flag lifted- Description: run the tests against Shelly.Lifted- Default: False--Test-Suite shelly-testsuite- type: exitcode-stdio-1.0- hs-source-dirs: src test/src- main-is: TestMain.hs- other-modules:- CopySpec- EnvSpec- FailureSpec- FindSpec- Help- LiftedSpec- MoveSpec- ReadFileSpec- RmSpec- RunSpec- SshSpec- Shelly- Shelly.Base- Shelly.Find- Shelly.Lifted- TestInit- WhichSpec- WriteSpec-- ghc-options: -O2 -Wall -fwarn-tabs -funbox-strict-fields -threaded- -fno-warn-unused-do-bind -fno-warn-type-defaults--- extensions: OverloadedStrings, ExtendedDefaultRules-- if flag(lifted)- cpp-options: -DLIFTED-- build-depends:- base >= 4.6,- text >= 0.11,- async,- bytestring >= 0.10,- containers >= 0.5.0.0,- directory >= 1.1.0.0 && < 1.4.0.0,- process >= 1.1.0,- unix-compat < 0.6,- system-filepath >= 0.4.7 && < 0.5,- system-fileio < 0.4,- time >= 1.3 && < 2,- mtl >= 2,- HUnit >= 1.2,- hspec >= 1.5,- transformers,- transformers-base,- filepath,- monad-control,- lifted-base,- lifted-async,- enclosed-exceptions,- exceptions-- extensions:- CPP--Flag build-examples- Description: build some example programs- Default: False- Manual: True---- demonstarated that command output in Shellish was not shown until after the command finished--- not necessary anymore-Executable drain- hs-source-dirs: test/examples- main-is: drain.hs- if flag(build-examples)- buildable: True-- build-depends: base >= 4.6- , shelly- , text-- extensions:- CPP- else- buildable: False--Executable run-handles- hs-source-dirs: test/examples- main-is: run-handles.hs- if flag(build-examples)- buildable: True-- build-depends: base >= 4.6- , shelly- , text-- extensions:- CPP- else- buildable: False--Executable Color- hs-source-dirs: test/examples- main-is: color.hs- if flag(build-examples)- buildable: True-- build-depends: base >= 4.6- , process- , shelly- , text- else- buildable: False
shelly/src/Shelly.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE ScopedTypeVariables, DeriveDataTypeable, OverloadedStrings,- FlexibleInstances, IncoherentInstances,+ FlexibleInstances, IncoherentInstances, CPP, TypeFamilies, ExistentialQuantification #-} -- | A module for shell-like programming in Haskell.
shelly/src/Shelly/Find.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE CPP #-} {-# LANGUAGE OverloadedStrings #-} -- | File finding utiliites for Shelly -- The basic 'find' takes a dir and gives back a list of files.
− shelly/src/Shelly/Lifted.hs
@@ -1,584 +0,0 @@-{-# LANGUAGE ScopedTypeVariables, DeriveDataTypeable, OverloadedStrings,- FlexibleInstances, FlexibleContexts, IncoherentInstances,- TypeFamilies, ExistentialQuantification, RankNTypes,- ImpredicativeTypes #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}---- | A module for shell-like programming in Haskell.--- Shelly's focus is entirely on ease of use for those coming from shell scripting.--- However, it also tries to use modern libraries and techniques to keep things efficient.------ The functionality provided by--- this module is (unlike standard Haskell filesystem functionality)--- thread-safe: each Sh maintains its own environment and its own working--- directory.------ Recommended usage includes putting the following at the top of your program,--- otherwise you will likely need either type annotations or type conversions------ > {-# LANGUAGE OverloadedStrings #-}--- > {-# LANGUAGE ExtendedDefaultRules #-}--- > {-# OPTIONS_GHC -fno-warn-type-defaults #-}--- > import Shelly--- > import qualified Data.Text as T--- > default (T.Text)-module Shelly.Lifted- (- MonadSh(..),- MonadShControl(..),-- -- This is copied from Shelly.hs, so that we are sure to export the- -- exact same set of symbols. Whenever that export list is updated,- -- please make the same updates here and implements the corresponding- -- lifted functions.-- -- * Entering Sh.- Sh, ShIO, S.shelly, S.shellyNoDir, S.shellyFailDir, sub- , silently, verbosely, escaping, print_stdout, print_stderr, print_commands- , tracing, errExit- , log_stdout_with, log_stderr_with-- -- * Running external commands.- , run, run_, runFoldLines, S.cmd, S.FoldCallback- , (-|-), lastStderr, setStdin, lastExitCode- , command, command_, command1, command1_- , sshPairs, sshPairs_- , S.ShellCmd(..), S.CmdArg (..)-- -- * Running commands Using handles- , runHandle, runHandles, transferLinesAndCombine, S.transferFoldHandleLines- , S.StdHandle(..), S.StdStream(..)--- -- * Modifying and querying environment.- , setenv, get_env, get_env_text, get_env_all, appendToPath, prependToPath-- -- * Environment directory- , cd, chdir, chdir_p, pwd-- -- * Printing- , echo, echo_n, echo_err, echo_n_err, inspect, inspect_err- , tag, trace, S.show_command-- -- * Querying filesystem.- , ls, lsT, test_e, test_f, test_d, test_s, test_px, which-- -- * Filename helpers- , absPath, (S.</>), (S.<.>), canonic, canonicalize, relPath, relativeTo- , S.hasExt-- -- * Manipulating filesystem.- , mv, rm, rm_f, rm_rf, cp, cp_r, mkdir, mkdir_p, mkdirTree-- -- * reading/writing Files- , readfile, readBinary, writefile, appendfile, touchfile, withTmpDir-- -- * exiting the program- , exit, errorExit, quietExit, terror-- -- * Exceptions- , bracket_sh, catchany, catch_sh, handle_sh, handleany_sh, finally_sh, catches_sh, catchany_sh-- -- * convert between Text and FilePath- , S.toTextIgnore, toTextWarn, FP.fromText-- -- * Utility Functions- , S.whenM, S.unlessM, time, sleep-- -- * Re-exported for your convenience- , liftIO, S.when, S.unless, FilePath, (S.<$>)-- -- * internal functions for writing extensions- , Shelly.Lifted.get, Shelly.Lifted.put-- -- * find functions- , S.find, S.findWhen, S.findFold, S.findDirFilter, S.findDirFilterWhen, S.findFoldDirFilter- , followSymlink- ) where--import qualified Shelly as S-import Shelly.Base (Sh(..), ShIO, Text, (>=>), FilePath)-import qualified Shelly.Base as S-import Control.Monad ( liftM )-import Prelude hiding ( FilePath )-import Data.ByteString ( ByteString )-import System.IO ( Handle )-import Data.Tree ( Tree )-import qualified Filesystem.Path.CurrentOS as FP--import Control.Exception.Lifted-import Control.Exception.Enclosed-import Control.Monad.IO.Class-import Control.Monad.Trans.Control-import Control.Monad.Trans.Identity-import Control.Monad.Trans.Maybe-import Control.Monad.Trans.Cont-import Control.Monad.Trans.Except-import Control.Monad.Trans.Reader-import Control.Monad.Trans.State-import qualified Control.Monad.Trans.State.Strict as Strict-import Control.Monad.Trans.Writer-import qualified Control.Monad.Trans.Writer.Strict as Strict-import qualified Control.Monad.Trans.RWS as RWS-import qualified Control.Monad.Trans.RWS.Strict as Strict--class Monad m => MonadSh m where- liftSh :: Sh a -> m a--instance MonadSh Sh where- liftSh = id--instance MonadSh m => MonadSh (IdentityT m) where- liftSh = IdentityT . liftSh-instance MonadSh m => MonadSh (MaybeT m) where- liftSh = MaybeT . liftM Just . liftSh-instance MonadSh m => MonadSh (ContT r m) where- liftSh m = ContT (liftSh m >>=)-instance MonadSh m => MonadSh (ExceptT e m) where- liftSh m = ExceptT $ do- a <- liftSh m- return (Right a)-instance MonadSh m => MonadSh (ReaderT r m) where- liftSh = ReaderT . const . liftSh-instance MonadSh m => MonadSh (StateT s m) where- liftSh m = StateT $ \s -> do- a <- liftSh m- return (a, s)-instance MonadSh m => MonadSh (Strict.StateT s m) where- liftSh m = Strict.StateT $ \s -> do- a <- liftSh m- return (a, s)-instance (Monoid w, MonadSh m) => MonadSh (WriterT w m) where- liftSh m = WriterT $ do- a <- liftSh m- return (a, mempty :: w)-instance (Monoid w, MonadSh m) => MonadSh (Strict.WriterT w m) where- liftSh m = Strict.WriterT $ do- a <- liftSh m- return (a, mempty :: w)-instance (Monoid w, MonadSh m) => MonadSh (RWS.RWST r w s m) where- liftSh m = RWS.RWST $ \_ s -> do- a <- liftSh m- return (a, s, mempty :: w)-instance (Monoid w, MonadSh m) => MonadSh (Strict.RWST r w s m) where- liftSh m = Strict.RWST $ \_ s -> do- a <- liftSh m- return (a, s, mempty :: w)--instance MonadSh m => S.ShellCmd (m Text) where- cmdAll = (liftSh .) . S.run--instance (MonadSh m, s ~ Text, Show s) => S.ShellCmd (m s) where- cmdAll = (liftSh .) . S.run--instance MonadSh m => S.ShellCmd (m ()) where- cmdAll = (liftSh .) . S.run_--class Monad m => MonadShControl m where- data ShM m a :: *- liftShWith :: ((forall x. m x -> Sh (ShM m x)) -> Sh a) -> m a- restoreSh :: ShM m a -> m a--instance MonadShControl Sh where- newtype ShM Sh a = ShSh a- liftShWith f = f $ liftM ShSh- restoreSh (ShSh x) = return x- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m => MonadShControl (MaybeT m) where- newtype ShM (MaybeT m) a = MaybeTShM (ShM m (Maybe a))- liftShWith f =- MaybeT $ liftM return $ liftShWith $ \runInSh -> f $ \k ->- liftM MaybeTShM $ runInSh $ runMaybeT k- restoreSh (MaybeTShM m) = MaybeT . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m- => MonadShControl (IdentityT m) where- newtype ShM (IdentityT m) a = IdentityTShM (ShM m a)- liftShWith f =- IdentityT $ liftM id $ liftShWith $ \runInSh -> f $ \k ->- liftM IdentityTShM $ runInSh $ runIdentityT k- restoreSh (IdentityTShM m) = IdentityT . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance (MonadShControl m, Monoid w)- => MonadShControl (WriterT w m) where- newtype ShM (WriterT w m) a = WriterTShM (ShM m (a, w))- liftShWith f =- WriterT $ liftM (\x -> (x, mempty :: w)) $ liftShWith $ \runInSh -> f $ \k ->- liftM WriterTShM $ runInSh $ runWriterT k- restoreSh (WriterTShM m) = WriterT . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance (MonadShControl m, Monoid w)- => MonadShControl (Strict.WriterT w m) where- newtype ShM (Strict.WriterT w m) a = StWriterTShM (ShM m (a, w))- liftShWith f =- Strict.WriterT $ liftM (\x -> (x, mempty :: w)) $ liftShWith $ \runInSh -> f $ \k ->- liftM StWriterTShM $ runInSh $ Strict.runWriterT k- restoreSh (StWriterTShM m) = Strict.WriterT . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m- => MonadShControl (ExceptT e m) where- newtype ShM (ExceptT e m) a = ErrorTShM (ShM m (Either e a))- liftShWith f =- ExceptT $ liftM return $ liftShWith $ \runInSh -> f $ \k ->- liftM ErrorTShM $ runInSh $ runExceptT k- restoreSh (ErrorTShM m) = ExceptT . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m => MonadShControl (StateT s m) where- newtype ShM (StateT s m) a = StateTShM (ShM m (a, s))- liftShWith f = StateT $ \s ->- liftM (\x -> (x,s)) $ liftShWith $ \runInSh -> f $ \k ->- liftM StateTShM $ runInSh $ runStateT k s- restoreSh (StateTShM m) = StateT . const . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m => MonadShControl (Strict.StateT s m) where- newtype ShM (Strict.StateT s m) a = StStateTShM (ShM m (a, s))- liftShWith f = Strict.StateT $ \s ->- liftM (\x -> (x,s)) $ liftShWith $ \runInSh -> f $ \k ->- liftM StStateTShM $ runInSh $ Strict.runStateT k s- restoreSh (StStateTShM m) = Strict.StateT . const . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance MonadShControl m => MonadShControl (ReaderT r m) where- newtype ShM (ReaderT r m) a = ReaderTShM (ShM m a)- liftShWith f = ReaderT $ \r ->- liftM id $ liftShWith $ \runInSh -> f $ \k ->- liftM ReaderTShM $ runInSh $ runReaderT k r- restoreSh (ReaderTShM m) = ReaderT . const . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance (MonadShControl m, Monoid w)- => MonadShControl (RWS.RWST r w s m) where- newtype ShM (RWS.RWST r w s m) a = RWSTShM (ShM m (a, s ,w))- liftShWith f = RWS.RWST $ \r s ->- liftM (\x -> (x,s,mempty :: w)) $ liftShWith $ \runInSh -> f $ \k ->- liftM RWSTShM $ runInSh $ RWS.runRWST k r s- restoreSh (RWSTShM m) = RWS.RWST . const . const . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--instance (MonadShControl m, Monoid w)- => MonadShControl (Strict.RWST r w s m) where- newtype ShM (Strict.RWST r w s m) a = StRWSTShM (ShM m (a, s, w))- liftShWith f = Strict.RWST $ \r s ->- liftM (\x -> (x,s,mempty :: w)) $ liftShWith $ \runInSh -> f $ \k ->- liftM StRWSTShM $ runInSh $ Strict.runRWST k r s- restoreSh (StRWSTShM m) = Strict.RWST . const . const . restoreSh $ m- {-# INLINE liftShWith #-}- {-# INLINE restoreSh #-}--controlSh :: MonadShControl m => ((forall x. m x -> Sh (ShM m x)) -> Sh (ShM m a)) -> m a-controlSh = liftShWith >=> restoreSh-{-# INLINE controlSh #-}--tag :: (MonadShControl m, MonadSh m) => m a -> Text -> m a-tag action msg = controlSh $ \runInSh -> S.tag (runInSh action) msg--chdir :: MonadShControl m => FilePath -> m a -> m a-chdir dir action = controlSh $ \runInSh -> S.chdir dir (runInSh action)--chdir_p :: MonadShControl m => FilePath -> m a -> m a-chdir_p dir action = controlSh $ \runInSh -> S.chdir_p dir (runInSh action)--silently :: MonadShControl m => m a -> m a-silently a = controlSh $ \runInSh -> S.silently (runInSh a)--verbosely :: MonadShControl m => m a -> m a-verbosely a = controlSh $ \runInSh -> S.verbosely (runInSh a)--log_stdout_with :: MonadShControl m => (Text -> IO ()) -> m a -> m a-log_stdout_with logger a = controlSh $ \runInSh -> S.log_stdout_with logger (runInSh a)--log_stderr_with :: MonadShControl m => (Text -> IO ()) -> m a -> m a-log_stderr_with logger a = controlSh $ \runInSh -> S.log_stderr_with logger (runInSh a)--print_stdout :: MonadShControl m => Bool -> m a -> m a-print_stdout shouldPrint a = controlSh $ \runInSh -> S.print_stdout shouldPrint (runInSh a)--print_stderr :: MonadShControl m => Bool -> m a -> m a-print_stderr shouldPrint a = controlSh $ \runInSh -> S.print_stderr shouldPrint (runInSh a)--print_commands :: MonadShControl m => Bool -> m a -> m a-print_commands shouldPrint a = controlSh $ \runInSh -> S.print_commands shouldPrint (runInSh a)--sub :: MonadShControl m => m a -> m a-sub a = controlSh $ \runInSh -> S.sub (runInSh a)--trace :: MonadSh m => Text -> m ()-trace = liftSh . S.trace--tracing :: MonadShControl m => Bool -> m a -> m a-tracing shouldTrace action = controlSh $ \runInSh -> S.tracing shouldTrace (runInSh action)--escaping :: MonadShControl m => Bool -> m a -> m a-escaping shouldEscape action = controlSh $ \runInSh -> S.escaping shouldEscape (runInSh action)--errExit :: MonadShControl m => Bool -> m a -> m a-errExit shouldExit action = controlSh $ \runInSh -> S.errExit shouldExit (runInSh action)--followSymlink :: MonadShControl m => Bool -> m a -> m a-followSymlink enableFollowSymlink action = controlSh $ \runInSh -> S.followSymlink enableFollowSymlink (runInSh action)--(-|-) :: (MonadShControl m, MonadSh m) => m Text -> m b -> m b-one -|- two = controlSh $ \runInSh -> do- x <- runInSh one- runInSh $ restoreSh x >>= \x' ->- controlSh $ \runInSh' -> return x' S.-|- runInSh' two--withTmpDir :: MonadShControl m => (FilePath -> m a) -> m a-withTmpDir action = controlSh $ \runInSh -> S.withTmpDir (fmap runInSh action)--time :: MonadShControl m => m a -> m (Double, a)-time what = controlSh $ \runInSh -> do- (d, a) <- S.time (runInSh what)- runInSh $ restoreSh a >>= \x -> return (d, x)--toTextWarn :: MonadSh m => FilePath -> m Text-toTextWarn = liftSh . toTextWarn--transferLinesAndCombine :: MonadIO m => Handle -> (Text -> IO ()) -> m Text-transferLinesAndCombine = (liftIO .) . S.transferLinesAndCombine--get :: MonadSh m => m S.State-get = liftSh S.get--put :: MonadSh m => S.State -> m ()-put = liftSh . S.put--catch_sh :: (Exception e) => Sh a -> (e -> Sh a) -> Sh a-catch_sh = Control.Exception.Lifted.catch-{-# DEPRECATED catch_sh "use Control.Exception.Lifted.catch instead" #-}--handle_sh :: (Exception e) => (e -> Sh a) -> Sh a -> Sh a-handle_sh = handle-{-# DEPRECATED handle_sh "use Control.Exception.Lifted.handle instead" #-}--finally_sh :: Sh a -> Sh b -> Sh a-finally_sh = finally-{-# DEPRECATED finally_sh "use Control.Exception.Lifted.finally instead" #-}--bracket_sh :: Sh a -> (a -> Sh b) -> (a -> Sh c) -> Sh c-bracket_sh = bracket-{-# DEPRECATED bracket_sh "use Control.Exception.Lifted.bracket instead" #-}--catches_sh :: Sh a -> [Handler Sh a] -> Sh a-catches_sh = catches-{-# DEPRECATED catches_sh "use Control.Exception.Lifted.catches instead" #-}--catchany_sh :: Sh a -> (SomeException -> Sh a) -> Sh a-catchany_sh = catchAny-{-# DEPRECATED catchany_sh "use Control.Exception.Enclosed.catchAny instead" #-}--handleany_sh :: (SomeException -> Sh a) -> Sh a -> Sh a-handleany_sh = handleAny-{-# DEPRECATED handleany_sh "use Control.Exception.Enclosed.handleAny instead" #-}--cd :: MonadSh m => FilePath -> m ()-cd = liftSh . S.cd--mv :: MonadSh m => FilePath -> FilePath -> m ()-mv = (liftSh .) . S.mv--lsT :: MonadSh m => FilePath -> m [Text]-lsT = liftSh . S.lsT--pwd :: MonadSh m => m FilePath-pwd = liftSh S.pwd--exit :: MonadSh m => Int -> m a-exit = liftSh . S.exit--errorExit :: MonadSh m => Text -> m a-errorExit = liftSh . S.errorExit--quietExit :: MonadSh m => Int -> m a-quietExit = liftSh . S.quietExit--terror :: MonadSh m => Text -> m a-terror = liftSh . S.terror--mkdir :: MonadSh m => FilePath -> m ()-mkdir = liftSh . S.mkdir--mkdir_p :: MonadSh m => FilePath -> m ()-mkdir_p = liftSh . S.mkdir_p--mkdirTree :: MonadSh m => Tree FilePath -> m ()-mkdirTree = liftSh . S.mkdirTree--which :: MonadSh m => FilePath -> m (Maybe FilePath)-which = liftSh . S.which--test_e :: MonadSh m => FilePath -> m Bool-test_e = liftSh . S.test_e--test_f :: MonadSh m => FilePath -> m Bool-test_f = liftSh . S.test_f--test_px :: MonadSh m => FilePath -> m Bool-test_px = liftSh . S.test_px--rm_rf :: MonadSh m => FilePath -> m ()-rm_rf = liftSh . S.rm_rf--rm_f :: MonadSh m => FilePath -> m ()-rm_f = liftSh . S.rm_f--rm :: MonadSh m => FilePath -> m ()-rm = liftSh . S.rm--setenv :: MonadSh m => Text -> Text -> m ()-setenv = (liftSh .) . S.setenv--appendToPath :: MonadSh m => FilePath -> m ()-appendToPath = liftSh . S.appendToPath--prependToPath :: MonadSh m => FilePath -> m ()-prependToPath = liftSh . S.prependToPath--get_env_all :: MonadSh m => m [(String, String)]-get_env_all = liftSh S.get_env_all--get_env :: MonadSh m => Text -> m (Maybe Text)-get_env = liftSh . S.get_env--get_env_text :: MonadSh m => Text -> m Text-get_env_text = liftSh . S.get_env_text--sshPairs_ :: MonadSh m => Text -> [(FilePath, [Text])] -> m ()-sshPairs_ = (liftSh .) . S.sshPairs_--sshPairs :: MonadSh m => Text -> [(FilePath, [Text])] -> m Text-sshPairs = (liftSh .) . S.sshPairs--run :: MonadSh m => FilePath -> [Text] -> m Text-run = (liftSh .) . S.run--command :: MonadSh m => FilePath -> [Text] -> [Text] -> m Text-command com args more_args =- liftSh $ S.command com args more_args--command_ :: MonadSh m => FilePath -> [Text] -> [Text] -> m ()-command_ com args more_args =- liftSh $ S.command_ com args more_args--command1 :: MonadSh m => FilePath -> [Text] -> Text -> [Text] -> m Text-command1 com args one_arg more_args =- liftSh $ S.command1 com args one_arg more_args--command1_ :: MonadSh m => FilePath -> [Text] -> Text -> [Text] -> m ()-command1_ com args one_arg more_args =- liftSh $ S.command1_ com args one_arg more_args--run_ :: MonadSh m => FilePath -> [Text] -> m ()-run_ = (liftSh .) . S.run_--runHandle :: MonadShControl m => FilePath -- ^ command- -> [Text] -- ^ arguments- -> (Handle -> m a) -- ^ stdout handle- -> m a-runHandle exe args withHandle =- controlSh $ \runInSh -> S.runHandle exe args (fmap runInSh withHandle)--runHandles :: MonadShControl m => FilePath -- ^ command- -> [Text] -- ^ arguments- -> [S.StdHandle] -- ^ optionally connect process i/o handles to existing handles- -> (Handle -> Handle -> Handle -> m a) -- ^ stdin, stdout and stderr- -> m a-runHandles exe args reusedHandles withHandles =- controlSh $ \runInSh ->- S.runHandles exe args reusedHandles (fmap (fmap (fmap runInSh)) withHandles)--runFoldLines :: MonadSh m => a -> S.FoldCallback a -> FilePath -> [Text] -> m a-runFoldLines start cb exe args = liftSh $ S.runFoldLines start cb exe args--lastStderr :: MonadSh m => m Text-lastStderr = liftSh S.lastStderr--lastExitCode :: MonadSh m => m Int-lastExitCode = liftSh S.lastExitCode--setStdin :: MonadSh m => Text -> m ()-setStdin = liftSh . S.setStdin--cp_r :: MonadSh m => FilePath -> FilePath -> m ()-cp_r = (liftSh .) . S.cp_r--cp :: MonadSh m => FilePath -> FilePath -> m ()-cp = (liftSh .) . S.cp--writefile :: MonadSh m => FilePath -> Text -> m ()-writefile = (liftSh .) . S.writefile--touchfile :: MonadSh m => FilePath -> m ()-touchfile = liftSh . S.touchfile--appendfile :: MonadSh m => FilePath -> Text -> m ()-appendfile = (liftSh .) . S.appendfile--readfile :: MonadSh m => FilePath -> m Text-readfile = liftSh . S.readfile--readBinary :: MonadSh m => FilePath -> m ByteString-readBinary = liftSh . S.readBinary--sleep :: MonadSh m => Int -> m ()-sleep = liftSh . S.sleep--echo, echo_n, echo_err, echo_n_err :: MonadSh m => Text -> m ()-echo = liftSh . S.echo-echo_n = liftSh . S.echo_n-echo_err = liftSh . S.echo_err-echo_n_err = liftSh . S.echo_n_err--relPath :: MonadSh m => FilePath -> m FilePath-relPath = liftSh . S.relPath--relativeTo :: MonadSh m => FilePath -- ^ anchor path, the prefix- -> FilePath -- ^ make this relative to anchor path- -> m FilePath-relativeTo = (liftSh .) . S.relativeTo--canonic :: MonadSh m => FilePath -> m FilePath-canonic = liftSh . canonic---- | Obtain a (reasonably) canonic file path to a filesystem object. Based on--- "canonicalizePath" in system-fileio.-canonicalize :: MonadSh m => FilePath -> m FilePath-canonicalize = liftSh . S.canonicalize--absPath :: MonadSh m => FilePath -> m FilePath-absPath = liftSh . S.absPath--test_d :: MonadSh m => FilePath -> m Bool-test_d = liftSh . S.test_d--test_s :: MonadSh m => FilePath -> m Bool-test_s = liftSh . S.test_s--ls :: MonadSh m => FilePath -> m [FilePath]-ls = liftSh . S.ls--inspect :: (Show s, MonadSh m) => s -> m ()-inspect = liftSh . S.inspect--inspect_err :: (Show s, MonadSh m) => s -> m ()-inspect_err = liftSh . S.inspect_err--catchany :: MonadBaseControl IO m => m a -> (SomeException -> m a) -> m a-catchany = Control.Exception.Lifted.catch
− shelly/src/Shelly/Pipe.hs
@@ -1,643 +0,0 @@-{-# LANGUAGE FlexibleInstances, TypeSynonymInstances, - TypeFamilies, ExistentialQuantification #-}--- | This module is a wrapper for the module "Shelly". --- The only difference is a main type 'Sh'. In this module --- 'Sh' contains a list of results. Actual definition of the type 'Sh' is:------ > import qualified Shelly as S--- >--- > newtype Sh a = Sh { unSh :: S.Sh [a] }------ This definition can simplify some filesystem commands. --- A monad bind operator becomes a pipe operator and we can write------ > findExt ext = findWhen (pure . hasExt ext)--- >--- > main :: IO ()--- > main = shs $ do--- > mkdir "new"--- > findExt "hs" "." >>= flip cp "new"--- > findExt "cpp" "." >>= rm_f --- > liftIO $ putStrLn "done"------ Monad methods "return" and ">>=" behave like methods for--- @ListT Shelly.Sh@, but ">>" forgets the number of --- the empty effects. So the last line prints @\"done\"@ only once. ------ Documentation in this module mostly just reference documentation from--- the main "Shelly" module.------ > {-# LANGUAGE OverloadedStrings #-}--- > {-# LANGUAGE ExtendedDefaultRules #-}--- > {-# OPTIONS_GHC -fno-warn-type-defaults #-}--- > import Shelly--- > import Data.Text as T--- > default (T.Text)-module Shelly.Pipe- (- -- * Entering Sh.- Sh, shs, shelly, shellyFailDir, shsFailDir, sub, silently, verbosely, escaping, print_stdout, print_commands, tracing, errExit, log_stdout_with, log_stderr_with- -- * List functions- , roll, unroll, liftSh- -- * Running external commands.- , FoldCallback- , run, run_, runFoldLines, cmd- , (-|-), lastStderr, setStdin, lastExitCode- , command, command_, command1, command1_- , sshPairs, sshPairs_-- -- * Modifying and querying environment.- , setenv, get_env, get_env_text, get_env_def, appendToPath, prependToPath-- -- * Environment directory- , cd, chdir, pwd-- -- * Printing- , echo, echo_n, echo_err, echo_n_err, inspect, inspect_err- , tag, trace, show_command-- -- * Querying filesystem.- , ls, lsT, test_e, test_f, test_d, test_s, which-- -- * Filename helpers- , absPath, (</>), (<.>), canonic, canonicalize, relPath, relativeTo- , hasExt-- -- * Manipulating filesystem.- , mv, rm, rm_f, rm_rf, cp, cp_r, mkdir, mkdir_p, mkdirTree-- -- * reading/writing Files- , readfile, readBinary, writefile, appendfile, touchfile, withTmpDir-- -- * exiting the program- , exit, errorExit, quietExit, terror-- -- * Exceptions- , catchany, catch_sh, finally_sh - , ShellyHandler(..), catches_sh- , catchany_sh-- -- * convert between Text and FilePath- , toTextIgnore, toTextWarn, fromText-- -- * Utilities.- , (<$>), whenM, unlessM, time-- -- * Re-exported for your convenience- , liftIO, when, unless, FilePath-- -- * internal functions for writing extensions- , get, put-- -- * find functions - , find, findWhen, findFold- , findDirFilter, findDirFilterWhen, findFoldDirFilter- , followSymlink- ) where--import Prelude hiding (FilePath)--import Control.Applicative-import Control.Monad-import Control.Monad.Trans-import Control.Exception hiding (handle)--import Filesystem.Path(FilePath)--import qualified Shelly as S--import Shelly(- (</>), (<.>), hasExt- , whenM, unlessM, toTextIgnore- , fromText, catchany- , FoldCallback)--import Data.Maybe(fromMaybe)-import Shelly.Base(State)-import Data.ByteString (ByteString)--import Data.Tree(Tree)--import Data.Text as T hiding (concat, all, find, cons)----- | This type is a simple wrapper for a type @Shelly.Sh@.--- 'Sh' contains a list of results. -newtype Sh a = Sh { unSh :: S.Sh [a] }--instance Functor Sh where- fmap f = Sh . fmap (fmap f) . unSh --instance Monad Sh where- return = Sh . return . return - a >>= f = Sh $ fmap concat $ mapM (unSh . f) =<< unSh a- a >> b = Sh $ unSh a >> unSh b--instance Applicative Sh where- pure = return- (<*>) = ap--instance Alternative Sh where- empty = mzero- (<|>) = mplus--instance MonadPlus Sh where- mzero = Sh $ return []- mplus a b = Sh $ liftA2 (++) (unSh a) (unSh b)--instance MonadIO Sh where- liftIO = sh1 liftIO------------------------------------------------------------ converters--sh0 :: S.Sh a -> Sh a-sh0 = Sh . fmap return--sh1 :: (a -> S.Sh b) -> (a -> Sh b) -sh1 f = \a -> sh0 (f a)--sh2 :: (a1 -> a2 -> S.Sh b) -> (a1 -> a2 -> Sh b) -sh2 f = \a b -> sh0 (f a b)--sh3 :: (a1 -> a2 -> a3 -> S.Sh b) -> (a1 -> a2 -> a3 -> Sh b) -sh3 f = \a b c -> sh0 (f a b c)--sh4 :: (a1 -> a2 -> a3 -> a4 -> S.Sh b) -> (a1 -> a2 -> a3 -> a4 -> Sh b) -sh4 f = \a b c d -> sh0 (f a b c d)--sh0s :: S.Sh [a] -> Sh a-sh0s = Sh--sh1s :: (a -> S.Sh [b]) -> (a -> Sh b) -sh1s f = \a -> sh0s (f a)--{- Just in case ...-sh2s :: (a1 -> a2 -> S.Sh [b]) -> (a1 -> a2 -> Sh b) -sh2s f = \a b -> sh0s (f a b)--sh3s :: (a1 -> a2 -> a3 -> S.Sh [b]) -> (a1 -> a2 -> a3 -> Sh b) -sh3s f = \a b c -> sh0s (f a b c)--}--lift1 :: (S.Sh a -> S.Sh b) -> (Sh a -> Sh b)-lift1 f = Sh . (mapM (f . return) =<< ) . unSh--lift2 :: (S.Sh a -> S.Sh b -> S.Sh c) -> (Sh a -> Sh b -> Sh c)-lift2 f a b = Sh $ join $ liftA2 (mapM2 f') (unSh a) (unSh b)- where f' = \x y -> f (return x) (return y)--mapM2 :: Monad m => (a -> b -> m c)-> [a] -> [b] -> m [c]-mapM2 f as bs = sequence $ liftA2 f as bs ----------------------------------------------------------------- | Unpack list of results.-unroll :: Sh a -> Sh [a]-unroll = Sh . fmap return . unSh ---- | Pack list of results. It performs @concat@ inside 'Sh'.-roll :: Sh [a] -> Sh a-roll = Sh . fmap concat . unSh---- | Transform result as list. It can be useful for filtering. -liftSh :: ([a] -> [b]) -> Sh a -> Sh b-liftSh f = Sh . fmap f . unSh----------------------------------------------------------------------- Entering Sh---- | see 'S.shelly'-shelly :: MonadIO m => Sh a -> m [a]-shelly = S.shelly . unSh---- | Performs 'shelly' and then an empty action @return ()@. -shs :: MonadIO m => Sh () -> m ()-shs x = shelly x >> return ()---- | see 'S.shellyFailDir'-shellyFailDir :: MonadIO m => Sh a -> m [a]-shellyFailDir = S.shellyFailDir . unSh---- | Performs 'shellyFailDir' and then an empty action @return ()@.-shsFailDir :: MonadIO m => Sh () -> m ()-shsFailDir x = shellyFailDir x >> return ()---- | see 'S.sub'-sub :: Sh a -> Sh a-sub = lift1 S.sub---- See 'S.siliently'-silently :: Sh a -> Sh a-silently = lift1 S.silently---- See 'S.verbosely-verbosely :: Sh a -> Sh a-verbosely = lift1 S.verbosely---- | see 'S.escaping'-escaping :: Bool -> Sh a -> Sh a-escaping b = lift1 (S.escaping b)---- | see 'S.log_stdout_with'-log_stdout_with :: (Text -> IO ()) -> Sh a -> Sh a-log_stdout_with logger = lift1 (S.log_stdout_with logger)---- | see 'S.log_stderr_with'-log_stderr_with :: (Text -> IO ()) -> Sh a -> Sh a-log_stderr_with logger = lift1 (S.log_stdout_with logger)---- | see 'S.print_stdout'-print_stdout :: Bool -> Sh a -> Sh a-print_stdout b = lift1 (S.print_stdout b)---- | see 'S.print_commands-print_commands :: Bool -> Sh a -> Sh a-print_commands b = lift1 (S.print_commands b)---- | see 'S.tracing'-tracing :: Bool -> Sh a -> Sh a-tracing b = lift1 (S.tracing b)---- | see 'S.errExit'-errExit :: Bool -> Sh a -> Sh a-errExit b = lift1 (S.errExit b)---- | see 'S.followSymlink'-followSymlink :: Bool -> Sh a -> Sh a-followSymlink b = lift1 (S.followSymlink b)---- | see 'S.run'-run :: FilePath -> [Text] -> Sh Text-run a b = sh0 $ S.run a b---- | see 'S.run_'-run_ :: FilePath -> [Text] -> Sh ()-run_ a b = sh0 $ S.run_ a b---- | see 'S.runFoldLines'-runFoldLines :: a -> FoldCallback a -> FilePath -> [Text] -> Sh a-runFoldLines a cb fp ts = sh0 $ S.runFoldLines a cb fp ts---- | see 'S.-|-'-(-|-) :: Sh Text -> Sh b -> Sh b-(-|-) = lift2 (S.-|-)---- | see 'S.lastStderr'-lastStderr :: Sh Text-lastStderr = sh0 S.lastStderr---- | see 'S.setStdin'-setStdin :: Text -> Sh ()-setStdin = sh1 S.setStdin ---- | see 'S.lastExitCode'-lastExitCode :: Sh Int-lastExitCode = sh0 S.lastExitCode---- | see 'S.command'-command :: FilePath -> [Text] -> [Text] -> Sh Text-command = sh3 S.command---- | see 'S.command_'-command_ :: FilePath -> [Text] -> [Text] -> Sh ()-command_ = sh3 S.command_----- | see 'S.command1'-command1 :: FilePath -> [Text] -> Text -> [Text] -> Sh Text-command1 = sh4 S.command1---- | see 'S.command1_'-command1_ :: FilePath -> [Text] -> Text -> [Text] -> Sh ()-command1_ = sh4 S.command1_---- | see 'S.sshPairs'-sshPairs :: Text -> [(FilePath, [Text])] -> Sh Text-sshPairs = sh2 S.sshPairs---- | see 'S.sshPairs_'-sshPairs_ :: Text -> [(FilePath, [Text])] -> Sh ()-sshPairs_ = sh2 S.sshPairs_---- | see 'S.setenv'-setenv :: Text -> Text -> Sh ()-setenv = sh2 S.setenv---- | see 'S.get_env'-get_env :: Text -> Sh (Maybe Text)-get_env = sh1 S.get_env---- | see 'S.get_env_text'-get_env_text :: Text -> Sh Text-get_env_text = sh1 S.get_env_text---- | see 'S.get_env_def'-get_env_def :: Text -> Text -> Sh Text-get_env_def a d = sh0 $ fmap (fromMaybe d) $ S.get_env a-{-# DEPRECATED get_env_def "use fromMaybe DEFAULT get_env" #-}---- | see 'S.appendToPath'-appendToPath :: FilePath -> Sh ()-appendToPath = sh1 S.appendToPath---- | see 'S.prependToPath'-prependToPath :: FilePath -> Sh ()-prependToPath = sh1 S.prependToPath---- | see 'S.cd'-cd :: FilePath -> Sh ()-cd = sh1 S.cd---- | see 'S.chdir'-chdir :: FilePath -> Sh a -> Sh a-chdir p = lift1 (S.chdir p)---- | see 'S.pwd'-pwd :: Sh FilePath-pwd = sh0 S.pwd---------------------------------------------------------------------- Printing ---- | Echo text to standard (error, when using _err variants) output. The _n--- variants do not print a final newline.-echo, echo_n_err, echo_err, echo_n :: Text -> Sh ()--echo = sh1 S.echo-echo_n_err = sh1 S.echo_n_err-echo_err = sh1 S.echo_err-echo_n = sh1 S.echo_n---- | see 'S.inspect'-inspect :: Show s => s -> Sh ()-inspect = sh1 S.inspect---- | see 'S.inspect_err'-inspect_err :: Show s => s -> Sh ()-inspect_err = sh1 S.inspect_err---- | see 'S.tag'-tag :: Sh a -> Text -> Sh a-tag a t = lift1 (flip S.tag t) a---- | see 'S.trace'-trace :: Text -> Sh ()-trace = sh1 S.trace---- | see 'S.show_command'-show_command :: FilePath -> [Text] -> Text-show_command = S.show_command----------------------------------------------------------------------- Querying filesystem---- | see 'S.ls'-ls :: FilePath -> Sh FilePath-ls = sh1s S.ls---- | see 'S.lsT'-lsT :: FilePath -> Sh Text-lsT = sh1s S.lsT---- | see 'S.test_e'-test_e :: FilePath -> Sh Bool-test_e = sh1 S.test_e---- | see 'S.test_f'-test_f :: FilePath -> Sh Bool-test_f = sh1 S.test_f---- | see 'S.test_d'-test_d :: FilePath -> Sh Bool-test_d = sh1 S.test_d---- | see 'S.test_s'-test_s :: FilePath -> Sh Bool-test_s = sh1 S.test_s---- | see 'S.which-which :: FilePath -> Sh (Maybe FilePath)-which = sh1 S.which-------------------------------------------------------------------------- Filename helpers---- | see 'S.absPath'-absPath :: FilePath -> Sh FilePath-absPath = sh1 S.absPath---- | see 'S.canonic'-canonic :: FilePath -> Sh FilePath-canonic = sh1 S.canonic---- | see 'S.canonicalize'-canonicalize :: FilePath -> Sh FilePath-canonicalize = sh1 S.canonicalize---- | see 'S.relPath'-relPath :: FilePath -> Sh FilePath-relPath = sh1 S.relPath---- | see 'S.relativeTo'-relativeTo :: FilePath -- ^ anchor path, the prefix- -> FilePath -- ^ make this relative to anchor path- -> Sh FilePath-relativeTo = sh2 S.relativeTo------------------------------------------------------------------ Manipulating filesystem---- | see 'S.mv'-mv :: FilePath -> FilePath -> Sh ()-mv = sh2 S.mv---- | see 'S.rm'-rm :: FilePath -> Sh ()-rm = sh1 S.rm---- | see 'S.rm_f'-rm_f :: FilePath -> Sh ()-rm_f = sh1 S.rm_f---- | see 'S.rm_rf'-rm_rf :: FilePath -> Sh ()-rm_rf = sh1 S.rm_rf---- | see 'S.cp'-cp :: FilePath -> FilePath -> Sh ()-cp = sh2 S.cp---- | see 'S.cp_r'-cp_r :: FilePath -> FilePath -> Sh ()-cp_r = sh2 S.cp_r---- | see 'S.mkdir'-mkdir :: FilePath -> Sh ()-mkdir = sh1 S.mkdir---- | see 'S.mkdir_p'-mkdir_p :: FilePath -> Sh ()-mkdir_p = sh1 S.mkdir_p---- | see 'S.mkdirTree'-mkdirTree :: Tree FilePath -> Sh ()-mkdirTree = sh1 S.mkdirTree---- | see 'S.readFile'-readfile :: FilePath -> Sh Text-readfile = sh1 S.readfile---- | see 'S.readBinary'-readBinary :: FilePath -> Sh ByteString-readBinary = sh1 S.readBinary---- | see 'S.writeFile'-writefile :: FilePath -> Text -> Sh ()-writefile = sh2 S.writefile---- | see 'S.touchFile'-touchfile :: FilePath -> Sh ()-touchfile = sh1 S.touchfile---- | see 'S.appendFile'-appendfile :: FilePath -> Text -> Sh ()-appendfile = sh2 S.appendfile---- | see 'S.withTmpDir'-withTmpDir :: (FilePath -> Sh a) -> Sh a-withTmpDir f = Sh $ S.withTmpDir (unSh . f)---------------------------------------------------------------------- find---- | see 'S.find'-find :: FilePath -> Sh FilePath-find = sh1s S.find---- | see 'S.findWhen'-findWhen :: (FilePath -> Sh Bool) -> FilePath -> Sh FilePath-findWhen p a = Sh $ S.findWhen (fmap and . unSh . p) a---- | see 'S.findFold'-findFold :: (a -> FilePath -> Sh a) -> a -> FilePath -> Sh a-findFold cons nil a = Sh $ S.findFold cons' nil' a- where nil' = return nil- cons' as dir = unSh $ roll $ mapM (flip cons dir) as---- | see 'S.findDirFilter'-findDirFilter :: (FilePath -> Sh Bool) -> FilePath -> Sh FilePath-findDirFilter p a = Sh $ S.findDirFilter (fmap and . unSh . p) a- --- | see 'S.findDirFilterWhen'-findDirFilterWhen :: (FilePath -> Sh Bool) -- ^ directory filter- -> (FilePath -> Sh Bool) -- ^ file filter- -> FilePath -- ^ directory- -> Sh FilePath-findDirFilterWhen dirPred filePred a = - Sh $ S.findDirFilterWhen - (fmap and . unSh . dirPred) - (fmap and . unSh . filePred)- a----- | see 'S.findFoldDirFilterWhen'-findFoldDirFilter :: (a -> FilePath -> Sh a) -> a -> (FilePath -> Sh Bool) -> FilePath -> Sh a-findFoldDirFilter cons nil p a = Sh $ S.findFoldDirFilter cons' nil' p' a- where p' = fmap and . unSh . p- nil' = return nil- cons' as dir = unSh $ roll $ mapM (flip cons dir) as- --------------------------------------------------------------- exiting the program ---- | see 'S.exit'-exit :: Int -> Sh ()-exit = sh1 S.exit---- | see 'S.errorExit'-errorExit :: Text -> Sh ()-errorExit = sh1 S.errorExit---- | see 'S.quietExit'-quietExit :: Int -> Sh ()-quietExit = sh1 S.quietExit---- | see 'S.terror'-terror :: Text -> Sh a-terror = sh1 S.terror----------------------------------------------------------------- Utilities---- | see 'S.catch_sh'-catch_sh :: (Exception e) => Sh a -> (e -> Sh a) -> Sh a-catch_sh a f = Sh $ S.catch_sh (unSh a) (unSh . f)---- | see 'S.catchany_sh'-catchany_sh :: Sh a -> (SomeException -> Sh a) -> Sh a-catchany_sh = catch_sh----- | see 'S.finally_sh'-finally_sh :: Sh a -> Sh b -> Sh a-finally_sh = lift2 S.finally_sh---- | see 'S.time'-time :: Sh a -> Sh (Double, a)-time = lift1 S.time---- | see 'S.ShellyHandler'-data ShellyHandler a = forall e . Exception e => ShellyHandler (e -> Sh a)---- | see 'S.catches_sh'-catches_sh :: Sh a -> [ShellyHandler a] -> Sh a-catches_sh a hs = Sh $ S.catches_sh (unSh a) (fmap convert hs)- where convert :: ShellyHandler a -> S.ShellyHandler [a]- convert (ShellyHandler f) = S.ShellyHandler (unSh . f)----------------------------------------------------------------- convert between Text and FilePath ---- | see 'S.toTextWarn'-toTextWarn :: FilePath -> Sh Text-toTextWarn = sh1 S.toTextWarn------------------------------------------------------------------ internal functions for writing extension --get :: Sh State-get = sh0 S.get--put :: State -> Sh ()-put = sh1 S.put------------------------------------------------------------- polyvariadic vodoo---- | Converter for the variadic argument version of 'run' called 'cmd'.-class ShellArg a where toTextArg :: a -> Text-instance ShellArg Text where toTextArg = id-instance ShellArg FilePath where toTextArg = toTextIgnore----- Voodoo to create the variadic function 'cmd'-class ShellCommand t where- cmdAll :: FilePath -> [Text] -> t--instance ShellCommand (Sh Text) where- cmdAll fp args = run fp args--instance (s ~ Text, Show s) => ShellCommand (Sh s) where- cmdAll fp args = run fp args---- note that Sh () actually doesn't work for its case (_<- cmd) when there is no type signature-instance ShellCommand (Sh ()) where- cmdAll fp args = run_ fp args--instance (ShellArg arg, ShellCommand result) => ShellCommand (arg -> result) where- cmdAll fp acc = \x -> cmdAll fp (acc ++ [toTextArg x])---- | see 'S.cmd'-cmd :: (ShellCommand result) => FilePath -> result-cmd fp = cmdAll fp []
− shelly/src/Shelly/Unix.hs
@@ -1,12 +0,0 @@-{-# LANGUAGE OverloadedStrings #-}---- | commands that only work on Unix-module Shelly.Unix- ( kill- ) where--import Shelly-import qualified Data.Text as T--kill :: Int -> Sh ()-kill pid = run_ "kill" ["-15", T.pack $ show pid]