Bump to 0.8.1

Add writeFile and appendFile
Add file reading functions
2018-04-06 17:22:57 +02:00 · 2018-04-06 17:22:38 +02:00 · 2018-04-06 16:42:40 +02:00 · 2017-01-14 20:16:25 +01:00 · 2016-06-14 19:32:33 +02:00 · 2016-06-14 19:32:14 +02:00
34 changed files with 1933 additions and 943 deletions
--- a/10
+++ b/10
@@ -1,3 +1,13 @@
+0.8.1
+	* add 'readFile', 'readFileEOF', 'writeFile' and 'appendFile'
+0.8.0
+	* 'copyDirRecursiveOverwrite', 'copyFileOverwrite', 'easyCopyOverwrite' and 'moveFileOverwrite' have been removed, instead use the versions without the *Overwrite suffix and pass in 'Strict' (for default behavior) or 'Overwrite' as the CopyMode argument
+	* introduced a new 'RecursiveErrorMode' type to allow controlling recursive behavior of 'copyDirRecursive' (use 'FailEarly' for default behavior)
+	* 'createRegularFile' and 'createDir' now take FileMode as a parameter (also see 'newFilePerms' and 'newDirPerms')
+	* various documentation fixes
+	* improved reliability of tests
+0.7.5:
+	* relicense to BSD3
 0.7.3:
 	* don't expose HPath.Internal
 0.7.2:
--- a/358
+++ b/358
@@ -1,340 +1,30 @@
-             GNU GENERAL PUBLIC LICENSE
-                Version 2, June 1991
+Copyright (c) Julian Ospald

- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+All rights reserved.

-                     Preamble
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:

-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.

-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.

-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-             GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                     NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-              END OF TERMS AND CONDITIONS
-
-     How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
+3. Neither the name of the author nor the names of his contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.

+THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
--- a/hpath.cabal
+++ b/hpath.cabal
@@ -1,8 +1,8 @@
 name:                hpath
-version:             0.7.3
+version:             0.8.1
 synopsis:            Support for well-typed paths
 description:         Support for well-typed paths, utilizing ByteString under the hood.
-license:             GPL-2
+license:             BSD3
 license-file:        LICENSE
 author:              Julian Ospald <hasufell@posteo.de>
 maintainer:          Julian Ospald <hasufell@posteo.de>
@@ -19,18 +19,21 @@ extra-source-files:  README.md
 library
  hs-source-dirs:    src/
  default-language:  Haskell2010
-  ghc-options:       -Wall
+  if impl(ghc >= 8.0)
+    ghc-options:       -Wall -Wno-redundant-constraints
+  else
+    ghc-options:       -Wall
  c-sources:         cbits/dirutils.c
  exposed-modules:   HPath,
                     HPath.IO,
                     HPath.IO.Errors,
-                     HPath.IO.Utils,
                     System.Posix.Directory.Foreign,
                     System.Posix.Directory.Traversals,
                     System.Posix.FD,
                     System.Posix.FilePath
  other-modules:     HPath.Internal
  build-depends:     base >= 4.2 && <5
+                   , IfElse
                   , bytestring >= 0.9.2.0
                   , deepseq
                   , exceptions
@@ -73,11 +76,13 @@ test-suite spec
  Main-Is:              Main.hs
  other-modules:
                        HPath.IO.CanonicalizePathSpec
+                        HPath.IO.CopyDirRecursiveCollectFailuresSpec
                        HPath.IO.CopyDirRecursiveOverwriteSpec
                        HPath.IO.CopyDirRecursiveSpec
                        HPath.IO.CopyFileOverwriteSpec
                        HPath.IO.CopyFileSpec
                        HPath.IO.CreateDirSpec
+                        HPath.IO.CreateDirRecursiveSpec
                        HPath.IO.CreateRegularFileSpec
                        HPath.IO.CreateSymlinkSpec
                        HPath.IO.DeleteDirRecursiveSpec
@@ -87,6 +92,7 @@ test-suite spec
                        HPath.IO.GetFileTypeSpec
                        HPath.IO.MoveFileOverwriteSpec
                        HPath.IO.MoveFileSpec
+                        HPath.IO.RecreateSymlinkOverwriteSpec
                        HPath.IO.RecreateSymlinkSpec
                        HPath.IO.RenameFileSpec
                        Spec
@@ -94,6 +100,7 @@ test-suite spec
  GHC-Options:          -Wall
  Build-Depends:        base
                      , HUnit
+                      , IfElse
                      , bytestring
                      , hpath
                      , hspec >= 1.3
--- a/src/HPath.hs
+++ b/src/HPath.hs
@@ -314,10 +314,6 @@ getAllParents (MkPath p)

 -- | Extract the directory name of a path.
 --
-- The following properties hold:
--
-- @dirname (p \<\/> a) == dirname p@
--
 -- >>> dirname (MkPath "/abc/def/dod")
 -- "/abc/def"
 -- >>> dirname (MkPath "/")
@@ -336,6 +332,8 @@ dirname (MkPath fp) = MkPath (takeDirectory $ dropTrailingPathSeparator fp)
 --
 -- >>> basename (MkPath "/abc/def/dod") :: Maybe (Path Fn)
 -- Just "dod"
+-- >>> basename (MkPath "/abc/def/dod/") :: Maybe (Path Fn)
+-- Just "dod"
 -- >>> basename (MkPath "/")            :: Maybe (Path Fn)
 -- Nothing
 basename :: MonadThrow m => Path b -> m (Path Fn)
--- a/src/HPath/IO.hs
+++ b/src/HPath/IO.hs
@@ -1,7 +1,7 @@
 -- |
 -- Module      :  HPath.IO
 -- Copyright   :  © 2016 Julian Ospald
-- License     :  GPL-2
+-- License     :  BSD3
 --
 -- Maintainer  :  Julian Ospald <hasufell@posteo.de>
 -- Stability   :  experimental
@@ -37,14 +37,13 @@ module HPath.IO
  (
  -- * Types
    FileType(..)
+  , RecursiveErrorMode(..)
+  , CopyMode(..)
  -- * File copying
  , copyDirRecursive
-  , copyDirRecursiveOverwrite
  , recreateSymlink
  , copyFile
-  , copyFileOverwrite
  , easyCopy
-  , easyCopyOverwrite
  -- * File deletion
  , deleteFile
  , deleteDir
@@ -56,11 +55,17 @@ module HPath.IO
  -- * File creation
  , createRegularFile
  , createDir
+  , createDirRecursive
  , createSymlink
  -- * File renaming/moving
  , renameFile
  , moveFile
-  , moveFileOverwrite
+  -- * File reading
+  , readFile
+  , readFileEOF
+  -- * File writing
+  , writeFile
+  , appendFile
  -- * File permissions
  , newFilePerms
  , newDirPerms
@@ -80,26 +85,54 @@ import Control.Applicative
  )
 import Control.Exception
  (
-    bracket
+    IOException
+  , bracket
  , throwIO
  )
 import Control.Monad
  (
-    void
+    unless
+  , void
  , when
  )
+import Control.Monad.IfElse
+  (
+    unlessM
+  )
 import Data.ByteString
  (
    ByteString
  )
+import Data.ByteString.Builder
+  (
+    Builder
+  , byteString
+  , toLazyByteString
+  )
+import qualified Data.ByteString.Lazy as L
+import Data.ByteString.Unsafe
+  (
+    unsafePackCStringFinalizer
+  )
 import Data.Foldable
  (
    for_
  )
+import Data.IORef
+  (
+    IORef
+  , modifyIORef
+  , newIORef
+  , readIORef
+  )
 import Data.Maybe
  (
    catMaybes
  )
+import Data.Monoid
+  (
+    (<>)
+  )
 import Data.Word
  (
    Word8
@@ -108,9 +141,11 @@ import Foreign.C.Error
  (
    eEXIST
  , eINVAL
+  , eNOENT
  , eNOSYS
  , eNOTEMPTY
  , eXDEV
+  , getErrno
  )
 import Foreign.C.Types
  (
@@ -131,8 +166,7 @@ import GHC.IO.Exception
 import HPath
 import HPath.Internal
 import HPath.IO.Errors
-import HPath.IO.Utils
-import Prelude hiding (readFile)
+import Prelude hiding (appendFile, readFile, writeFile)
 import System.IO.Error
  (
    catchIOError
@@ -213,6 +247,28 @@ data FileType = Directory



+-- |The error mode for recursive operations.
+--
+-- On `FailEarly` the whole operation fails immediately if any of the
+-- recursive sub-operations fail, which is sort of the default
+-- for IO operations.
+--
+-- On `CollectFailures` skips errors in the recursion and keeps on recursing.
+-- However all errors are collected in the `RecursiveFailure` error type,
+-- which is raised finally if there was any error. Also note that
+-- `RecursiveFailure` does not give any guarantees on the ordering
+-- of the collected exceptions.
+data RecursiveErrorMode = FailEarly
+                        | CollectFailures
+
+
+-- |The mode for copy and file moves.
+-- Overwrite mode is usually not very well defined, but is a convenience
+-- shortcut.
+data CopyMode = Strict    -- ^ fail if any target exists
+              | Overwrite -- ^ overwrite targets
+
+


    --------------------
@@ -221,12 +277,22 @@ data FileType = Directory



-- |Copies a directory recursively to the given destination.
-- Does not follow symbolic links.
+-- |Copies the contents of a directory recursively to the given destination, while preserving permissions.
+-- Does not follow symbolic links. This behaves more or less like
+-- the following, without descending into the destination if it
+-- already exists:
 --
-- For directory contents, this has the same behavior as `easyCopy`
-- and thus will ignore any file type that is not `RegularFile`,
-- `SymbolicLink` or `Directory`.
+-- @
+--   cp -a \/source\/dir \/destination\/somedir
+-- @
+--
+-- For directory contents, this will ignore any file type that is not
+-- `RegularFile`, `SymbolicLink` or `Directory`.
+--
+-- For `Overwrite` copy mode this does not prune destination directory
+-- contents, so the destination might contain more files than the source after
+-- the operation has completed. Permissions of existing directories are
+-- fixed.
 --
 -- Safety/reliability concerns:
 --
@@ -240,113 +306,138 @@ data FileType = Directory
 -- Throws:
 --
 --    - `NoSuchThing` if source directory does not exist
--    - `PermissionDenied` if output directory is not writable
 --    - `PermissionDenied` if source directory can't be opened
+--    - `SameFile` if source and destination are the same file
+--      (`HPathIOException`)
+--    - `DestinationInSource` if destination is contained in source
+--      (`HPathIOException`)
+--
+-- Throws in `FailEarly` RecursiveErrorMode only:
+--
+--    - `PermissionDenied` if output directory is not writable
 --    - `InvalidArgument` if source directory is wrong type (symlink)
--    - `InvalidArgument` if source directory is wrong type (regular file)
+--    - `InappropriateType` if source directory is wrong type (regular file)
+--
+-- Throws in `CollectFailures` RecursiveErrorMode only:
+--
+--    - `RecursiveFailure` if any of the recursive operations that are not
+--      part of the top-directory sanity-checks fail (`HPathIOException`)
+--
+-- Throws in `Strict` CopyMode only:
+--
 --    - `AlreadyExists` if destination already exists
--    - `SameFile` if source and destination are the same file (`HPathIOException`)
--    - `DestinationInSource` if destination is contained in source (`HPathIOException`)
 copyDirRecursive :: Path Abs  -- ^ source dir
-                 -> Path Abs  -- ^ full destination
+                 -> Path Abs  -- ^ destination (parent dirs
+                              --   are not automatically created)
+                 -> CopyMode
+                 -> RecursiveErrorMode
                 -> IO ()
-copyDirRecursive fromp destdirp
+copyDirRecursive fromp destdirp cm rm
  = do
+    ce <- newIORef []
    -- for performance, sanity checks are only done for the top dir
    throwSameFile fromp destdirp
    throwDestinationInSource fromp destdirp
-    go fromp destdirp
+    go ce fromp destdirp
+    collectedExceptions <- readIORef ce
+    unless (null collectedExceptions)
+           (throwIO . RecursiveFailure $ collectedExceptions)
  where
-    go :: Path Abs -> Path Abs -> IO ()
-    go fromp' destdirp' = do
-      -- order is important here, so we don't get empty directories
+    go :: IORef [(RecursiveFailureHint, IOException)]
+       -> Path Abs -> Path Abs -> IO ()
+    go ce fromp' destdirp' = do
+
+      -- NOTE: order is important here, so we don't get empty directories
      -- on failure
-      contents <- getDirsFiles fromp'

-      fmode' <- PF.fileMode <$> PF.getSymbolicLinkStatus (fromAbs fromp')
-      createDirectory (fromAbs destdirp') fmode'
+      -- get the contents of the source dir
+      contents <- handleIOE (ReadContentsFailed fromp' destdirp') ce [] $ do
+        contents <- getDirsFiles fromp'

-      -- we can't use `easyCopy` here, because we want to call `go`
+        -- create the destination dir and
+        -- only return contents if we succeed
+        handleIOE (CreateDirFailed fromp' destdirp') ce [] $ do
+          fmode' <- PF.fileMode <$> PF.getSymbolicLinkStatus (fromAbs fromp')
+          case cm of
+            Strict    -> createDirectory (fromAbs destdirp') fmode'
+            Overwrite -> catchIOError (createDirectory (fromAbs destdirp')
+                                                       fmode')
+                           $ \e ->
+                             case ioeGetErrorType e of
+                               AlreadyExists -> setFileMode (fromAbs destdirp')
+                                                            fmode'
+                               _             -> ioError e
+          return contents
+
+      -- NOTE: we can't use `easyCopy` here, because we want to call `go`
      -- recursively to skip the top-level sanity checks
+
+      -- if reading the contents and creating the destination dir worked,
+      -- then copy the contents to the destination too
      for_ contents $ \f -> do
        ftype <- getFileType f
        newdest <- (destdirp' </>) <$> basename f
        case ftype of
-          SymbolicLink -> recreateSymlink f newdest
-          Directory    -> go f newdest
-          RegularFile  -> copyFile f newdest
+          SymbolicLink -> handleIOE (RecreateSymlinkFailed f newdest) ce ()
+                            $ recreateSymlink f newdest cm
+          Directory    -> go ce f newdest
+          RegularFile  -> handleIOE (CopyFileFailed f newdest) ce ()
+                            $ copyFile f newdest cm
          _            -> return ()

-
-- |Like `copyDirRecursive` except it overwrites contents of directories
-- if any.
--
-- For directory contents, this has the same behavior as `easyCopyOverwrite`
-- and thus will ignore any file type that is not `RegularFile`,
-- `SymbolicLink` or `Directory`.
--
-- Throws:
--
--    - `NoSuchThing` if source directory does not exist
--    - `PermissionDenied` if output directory is not writable
--    - `PermissionDenied` if source directory can't be opened
--    - `InvalidArgument` if source directory is wrong type (symlink)
--    - `InvalidArgument` if source directory is wrong type (regular file)
--    - `SameFile` if source and destination are the same file (`HPathIOException`)
--    - `DestinationInSource` if destination is contained in source (`HPathIOException`)
-copyDirRecursiveOverwrite :: Path Abs  -- ^ source dir
-                          -> Path Abs  -- ^ full destination
-                          -> IO ()
-copyDirRecursiveOverwrite fromp destdirp
-  = do
-    -- for performance, sanity checks are only done for the top dir
-    throwSameFile fromp destdirp
-    throwDestinationInSource fromp destdirp
-    go fromp destdirp
-  where
-    go :: Path Abs -> Path Abs -> IO ()
-    go fromp' destdirp' = do
-      -- order is important here, so we don't get empty directories
-      -- on failure
-      contents <- getDirsFiles fromp'
-
-      fmode' <- PF.fileMode <$> PF.getSymbolicLinkStatus (fromAbs fromp')
-      catchIOError (createDirectory (fromAbs destdirp') fmode') $ \e ->
-        case ioeGetErrorType e of
-          AlreadyExists -> setFileMode (fromAbs destdirp') fmode'
-          _             -> ioError e
-
-      -- we can't use `easyCopyOverwrite` here, because we want to call `go`
-      -- recursively to skip the top-level sanity checks
-      for_ contents $ \f -> do
-        ftype <- getFileType f
-        newdest <- (destdirp' </>) <$> basename f
-        case ftype of
-          SymbolicLink -> whenM (doesFileExist newdest) (deleteFile newdest)
-                          >> recreateSymlink f newdest
-          Directory    -> go f newdest
-          RegularFile  -> copyFileOverwrite f newdest
-          _            -> return ()
+    -- helper to handle errors for both RecursiveErrorModes and return a
+    -- default value
+    handleIOE :: RecursiveFailureHint
+              -> IORef [(RecursiveFailureHint, IOException)]
+              -> a -> IO a -> IO a
+    handleIOE hint ce def = case rm of
+      FailEarly       -> handleIOError throwIO
+      CollectFailures -> handleIOError (\e -> modifyIORef ce ((hint, e):)
+                                         >> return def)


 -- |Recreate a symlink.
 --
+-- In `Overwrite` copy mode only files and empty directories are deleted.
+--
+-- Safety/reliability concerns:
+--
+--    * `Overwrite` mode is inherently non-atomic
+--
 -- Throws:
 --
 --    - `InvalidArgument` if source file is wrong type (not a symlink)
 --    - `PermissionDenied` if output directory cannot be written to
 --    - `PermissionDenied` if source directory cannot be opened
--    - `AlreadyExists` if destination file already exists
--    - `SameFile` if source and destination are the same file (`HPathIOException`)
+--    - `SameFile` if source and destination are the same file
+--      (`HPathIOException`)
+--
+--
+-- Throws in `Strict` mode only:
+--
+--    - `AlreadyExists` if destination already exists
+--
+-- Throws in `Overwrite` mode only:
+--
+--    - `UnsatisfiedConstraints` if destination file is non-empty directory
 --
 -- Note: calls `symlink`
 recreateSymlink :: Path Abs  -- ^ the old symlink file
                -> Path Abs  -- ^ destination file
+                -> CopyMode
                -> IO ()
-recreateSymlink symsource newsym
+recreateSymlink symsource newsym cm
  = do
    throwSameFile symsource newsym
    sympoint <- readSymbolicLink (fromAbs symsource)
+    case cm of
+      Strict -> return ()
+      Overwrite -> do
+        writable <- isWritable (dirname newsym)
+        isfile   <- doesFileExist newsym
+        isdir    <- doesDirectoryExist newsym
+        when (writable && isfile) (deleteFile newsym)
+        when (writable && isdir)  (deleteDir newsym)
    createSymbolicLink sympoint (fromAbs newsym)


@@ -358,8 +449,11 @@ recreateSymlink symsource newsym
 -- examine file types. For a more high-level version, use `easyCopy`
 -- instead.
 --
+-- In `Overwrite` copy mode only overwrites actual files, not directories.
+--
 -- Safety/reliability concerns:
 --
+--    * `Overwrite` mode is not atomic
 --    * when used on `CharacterDevice`, reads the "contents" and copies
 --      them to a regular file, which might take indefinitely
 --    * when used on `BlockDevice`, may either read the "contents"
@@ -374,61 +468,39 @@ recreateSymlink symsource newsym
 --    - `PermissionDenied` if output directory is not writable
 --    - `PermissionDenied` if source directory can't be opened
 --    - `InvalidArgument` if source file is wrong type (symlink or directory)
+--    - `SameFile` if source and destination are the same file
+--      (`HPathIOException`)
+--
+-- Throws in `Strict` mode only:
+--
 --    - `AlreadyExists` if destination already exists
--    - `SameFile` if source and destination are the same file (`HPathIOException`)
 --
 -- Note: calls `sendfile` and possibly `read`/`write` as fallback
 copyFile :: Path Abs  -- ^ source file
         -> Path Abs  -- ^ destination file
+         -> CopyMode
         -> IO ()
-copyFile from to = do
+copyFile from to cm = do
  throwSameFile from to
-  _copyFile [SPDF.oNofollow]
-            [SPDF.oNofollow, SPDF.oExcl]
-            from to
-
-
-- |Like `copyFile` except it overwrites the destination if it already
-- exists.
--
-- Safety/reliability concerns:
--
--    * when used on `CharacterDevice`, reads the "contents" and copies
--      them to a regular file, which might take indefinitely
--    * when used on `BlockDevice`, may either read the "contents"
--      and copy them to a regular file (potentially hanging indefinitely)
--      or may create a regular empty destination file
--    * when used on `NamedPipe`, will hang indefinitely
--    * not atomic, since it uses read/write
--
-- Throws:
--
--    - `NoSuchThing` if source file does not exist
--    - `NoSuchThing` if source file is a `Socket`
--    - `PermissionDenied` if output directory is not writable
--    - `PermissionDenied` if source directory can't be opened
--    - `InvalidArgument` if source file is wrong type (symlink or directory)
--    - `SameFile` if source and destination are the same file (`HPathIOException`)
--
-- Note: calls `sendfile` and possibly `read`/`write` as fallback
-copyFileOverwrite :: Path Abs  -- ^ source file
-                  -> Path Abs  -- ^ destination file
-                  -> IO ()
-copyFileOverwrite from to = do
-  throwSameFile from to
-  catchIOError (_copyFile [SPDF.oNofollow]
-                          [SPDF.oNofollow, SPDF.oTrunc]
-                          from to) $ \e ->
-    case ioeGetErrorType e of
-      -- if the destination file is not writable, we need to
-      -- figure out if we can still copy by deleting it first
-      PermissionDenied -> do
-        exists   <- doesFileExist to
-        writable <- isWritable (dirname to)
-        if exists && writable
-          then deleteFile to >> copyFile from to
-          else ioError e
-      _ -> ioError e
+  
+  case cm of
+    Strict -> _copyFile [SPDF.oNofollow]
+                        [SPDF.oNofollow, SPDF.oExcl]
+                        from to
+    Overwrite -> 
+      catchIOError (_copyFile [SPDF.oNofollow]
+                              [SPDF.oNofollow, SPDF.oTrunc]
+                              from to) $ \e ->
+        case ioeGetErrorType e of
+          -- if the destination file is not writable, we need to
+          -- figure out if we can still copy by deleting it first
+          PermissionDenied -> do
+            exists   <- doesFileExist to
+            writable <- isWritable (dirname to)
+            if exists && writable
+              then deleteFile to >> copyFile from to Strict
+              else ioError e
+          _ -> ioError e


 _copyFile :: [SPDF.Flags]
@@ -439,8 +511,8 @@ _copyFile :: [SPDF.Flags]
 _copyFile sflags dflags from to
  =
    -- from sendfile(2) manpage:
-    --   Applications  may  wish  to  fall back to read(2)/write(2) in the case
-    --   where sendfile() fails with EINVAL or ENOSYS.
+    --   Applications  may  wish  to  fall back to read(2)/write(2) in
+    --   the case where sendfile() fails with EINVAL or ENOSYS.
    withAbsPath to $ \to' -> withAbsPath from $ \from' ->
      catchErrno [eINVAL, eNOSYS]
                 (sendFileCopy from' to')
@@ -476,7 +548,8 @@ _copyFile sflags dflags from to
            if size == 0
              then return $ fromIntegral totalsize
              else do rsize <- SPB.fdWriteBuf dfd buf size
-                      when (rsize /= size) (throwIO . CopyFailed $ "wrong size!")
+                      when (rsize /= size) (ioError $ userError
+                                                      "wrong size!")
                      write' sfd dfd buf (totalsize + fromIntegral size)


@@ -490,38 +563,18 @@ _copyFile sflags dflags from to
 --    * calls `copyDirRecursive` for directories
 easyCopy :: Path Abs
         -> Path Abs
+         -> CopyMode
+         -> RecursiveErrorMode
         -> IO ()
-easyCopy from to = do
+easyCopy from to cm rm = do
  ftype <- getFileType from
  case ftype of
-       SymbolicLink -> recreateSymlink from to
-       RegularFile  -> copyFile from to
-       Directory    -> copyDirRecursive from to
+       SymbolicLink -> recreateSymlink from to cm
+       RegularFile  -> copyFile from to cm
+       Directory    -> copyDirRecursive from to cm rm
       _            -> return ()


-- |Like `easyCopy` except it overwrites the destination if it already exists.
-- For directories, this overwrites contents without pruning them, so the resulting
-- directory may have more files than have been copied.
--
-- Safety/reliability concerns:
--
--    * examines filetypes explicitly
--    * calls `copyDirRecursive` for directories
-easyCopyOverwrite :: Path Abs
-                  -> Path Abs
-                  -> IO ()
-easyCopyOverwrite from to = do
-  ftype <- getFileType from
-  case ftype of
-       SymbolicLink -> whenM (doesFileExist to) (deleteFile to)
-                       >> recreateSymlink from to
-       RegularFile  -> copyFileOverwrite from to
-       Directory    -> copyDirRecursiveOverwrite from to
-       _            -> return ()
-
-
-



@@ -644,15 +697,18 @@ executeFile fp args
    ---------------------


-- |Create an empty regular file at the given directory with the given filename.
+-- |Create an empty regular file at the given directory with the given
+-- filename.
 --
 -- Throws:
 --
 --    - `PermissionDenied` if output directory cannot be written to
--    - `AlreadyExists` if destination file already exists
-createRegularFile :: Path Abs -> IO ()
-createRegularFile dest =
-  bracket (SPI.openFd (fromAbs dest) SPI.WriteOnly (Just newFilePerms)
+--    - `AlreadyExists` if destination already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+createRegularFile :: FileMode -> Path Abs -> IO ()
+createRegularFile fm dest =
+  bracket (SPI.openFd (fromAbs dest) SPI.WriteOnly (Just fm)
                      (SPI.defaultFileFlags { exclusive = True }))
          SPI.closeFd
          (\_ -> return ())
@@ -663,9 +719,40 @@ createRegularFile dest =
 -- Throws:
 --
 --    - `PermissionDenied` if output directory cannot be written to
--    - `AlreadyExists` if destination directory already exists
-createDir :: Path Abs -> IO ()
-createDir dest = createDirectory (fromAbs dest) newDirPerms
+--    - `AlreadyExists` if destination already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+createDir :: FileMode -> Path Abs -> IO ()
+createDir fm dest = createDirectory (fromAbs dest) fm
+
+
+-- |Create an empty directory at the given directory with the given filename.
+-- All parent directories are created with the same filemode. This
+-- basically behaves like:
+--
+-- @
+--   mkdir -p \/some\/dir
+-- @
+--
+-- Safety/reliability concerns:
+--
+--    * not atomic
+--
+-- Throws:
+--
+--    - `PermissionDenied` if any part of the path components do not
+--      exist and cannot be written to
+--    - `AlreadyExists` if destination already exists and
+--      is not a directory
+createDirRecursive :: FileMode -> Path Abs -> IO ()
+createDirRecursive fm dest =
+  catchIOError (createDirectory (fromAbs dest) fm) $ \e -> do
+    errno <- getErrno
+    case errno of
+         en | en == eEXIST -> unlessM (doesDirectoryExist dest) (ioError e)
+            | en == eNOENT -> createDirRecursive fm (dirname dest)
+                              >> createDirectory (fromAbs dest) fm
+            | otherwise    -> ioError e


 -- |Create a symlink.
@@ -674,6 +761,8 @@ createDir dest = createDirectory (fromAbs dest) newDirPerms
 --
 --    - `PermissionDenied` if output directory cannot be written to
 --    - `AlreadyExists` if destination file already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
 --
 -- Note: calls `symlink`
 createSymlink :: Path Abs   -- ^ destination file
@@ -703,10 +792,11 @@ createSymlink dest sympoint
 --     - `NoSuchThing` if source file does not exist
 --     - `PermissionDenied` if output directory cannot be written to
 --     - `PermissionDenied` if source directory cannot be opened
--     - `UnsupportedOperation` if source and destination are on different devices
--     - `FileDoesExist` if destination file already exists (`HPathIOException`)
--     - `DirDoesExist` if destination directory already exists (`HPathIOException`)
--     - `SameFile` if destination and source are the same file (`HPathIOException`)
+--     - `UnsupportedOperation` if source and destination are on different
+--       devices
+--     - `AlreadyExists` if destination already exists
+--     - `SameFile` if destination and source are the same file
+--       (`HPathIOException`)
 --
 -- Note: calls `rename` (but does not allow to rename over existing files)
 renameFile :: Path Abs -> Path Abs -> IO ()
@@ -725,70 +815,158 @@ renameFile fromf tof = do
 --
 -- Safety/reliability concerns:
 --
+--    * `Overwrite` mode is not atomic
 --    * copy-delete fallback is inherently non-atomic
 --    * since this function calls `easyCopy` and `easyDelete` as a fallback
 --      to `renameFile`, file types that are not `RegularFile`, `SymbolicLink`
 --      or `Directory` may be ignored
+--    * for `Overwrite` mode, the destination will be deleted (not recursively)
+--      before moving
 --
 -- Throws:
 --
 --     - `NoSuchThing` if source file does not exist
 --     - `PermissionDenied` if output directory cannot be written to
 --     - `PermissionDenied` if source directory cannot be opened
--     - `FileDoesExist` if destination file already exists (`HPathIOException`)
--     - `DirDoesExist` if destination directory already exists (`HPathIOException`)
--     - `SameFile` if destination and source are the same file (`HPathIOException`)
+--     - `SameFile` if destination and source are the same file
+--       (`HPathIOException`)
+--
+-- Throws in `Strict` mode only:
+--
+--    - `AlreadyExists` if destination already exists
 --
 -- Note: calls `rename` (but does not allow to rename over existing files)
 moveFile :: Path Abs  -- ^ file to move
         -> Path Abs  -- ^ destination
+         -> CopyMode
         -> IO ()
-moveFile from to = do
+moveFile from to cm = do
  throwSameFile from to
-  catchErrno [eXDEV] (renameFile from to) $ do
-    easyCopy from to
-    easyDelete from
+  case cm of
+    Strict -> catchErrno [eXDEV] (renameFile from to) $ do
+                easyCopy from to Strict FailEarly
+                easyDelete from
+    Overwrite -> do
+      ft <- getFileType from
+      writable <- isWritable $ dirname to
+      case ft of
+        RegularFile -> do
+          exists <- doesFileExist to
+          when (exists && writable) (deleteFile to)
+        SymbolicLink -> do
+          exists <- doesFileExist to
+          when (exists && writable) (deleteFile to)
+        Directory -> do
+          exists <- doesDirectoryExist to
+          when (exists && writable) (deleteDir to)
+        _ -> return ()
+      moveFile from to Strict


-- |Like `moveFile`, but overwrites the destination if it exists.
+
+
+
+    --------------------
+    --[ File Reading ]--
+    --------------------
+
+
+-- |Read the given file at once into memory as a strict ByteString.
+-- Symbolic links are followed, no sanity checks on file size
+-- or file type. File must exist.
 --
-- Does not follow symbolic links, but renames the symbolic link file.
--
-- Ignores any file type that is not `RegularFile`, `SymbolicLink` or
-- `Directory`.
+-- Note: the size of the file is determined in advance, as to only
+-- have one allocation.
 --
 -- Safety/reliability concerns:
 --
--    * copy-delete fallback is inherently non-atomic
--    * checks for file types and destination file existence explicitly
+--    * since amount of bytes to read is determined in advance,
+--      the file might be read partially only if something else is
+--      appending to it while reading
+--    * the whole file is read into memory!
 --
 -- Throws:
 --
--     - `NoSuchThing` if source file does not exist
--     - `PermissionDenied` if output directory cannot be written to
--     - `PermissionDenied` if source directory cannot be opened
--     - `SameFile` if destination and source are the same file (`HPathIOException`)
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+readFile :: Path Abs -> IO ByteString
+readFile p = withAbsPath p $ \fp ->
+  bracket (openFd fp SPI.ReadOnly [] Nothing) (SPI.closeFd) $ \fd -> do
+    stat <- PF.getFdStatus fd
+    let fsize = PF.fileSize stat
+    SPB.fdRead fd (fromIntegral fsize)
+
+
+-- |Read the given file in chunks of size `8192` into memory until
+-- `fread` returns 0. Returns a lazy ByteString, because it uses
+-- Builders under the hood.
 --
-- Note: calls `rename` (but does not allow to rename over existing files)
-moveFileOverwrite :: Path Abs  -- ^ file to move
-                  -> Path Abs  -- ^ destination
-                  -> IO ()
-moveFileOverwrite from to = do
-  throwSameFile from to
-  ft <- getFileType from
-  writable <- isWritable $ dirname to
-  case ft of
-    RegularFile -> do
-      exists <- doesFileExist to
-      when (exists && writable) (deleteFile to)
-    SymbolicLink -> do
-      exists <- doesFileExist to
-      when (exists && writable) (deleteFile to)
-    Directory -> do
-      exists <- doesDirectoryExist to
-      when (exists && writable) (deleteDir to)
-    _ -> return ()
-  moveFile from to
+-- Safety/reliability concerns:
+--
+--    * the whole file is read into memory!
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+readFileEOF :: Path Abs -> IO L.ByteString
+readFileEOF p = withAbsPath p $ \fp ->
+  bracket (openFd fp SPI.ReadOnly [] Nothing) (SPI.closeFd) $ \fd ->
+    allocaBytes (fromIntegral bufSize) $ \buf -> read' fd buf mempty
+  where
+    bufSize :: CSize
+    bufSize = 8192
+    read' :: Fd -> Ptr Word8 -> Builder -> IO L.ByteString
+    read' fd buf builder = do
+        size <- SPB.fdReadBuf fd buf bufSize
+        if size == 0
+          then return $ toLazyByteString builder
+          else do
+            readBS <- unsafePackCStringFinalizer buf
+                                                 (fromIntegral size)
+                                                 mempty
+            read' fd buf (builder <> byteString readBS)
+
+
+
+
+    --------------------
+    --[ File Writing ]--
+    --------------------
+
+
+-- |Write a given ByteString to a file, truncating the file beforehand.
+-- The file must exist. Follows symlinks.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+writeFile :: Path Abs -> ByteString -> IO ()
+writeFile p bs = withAbsPath p $ \fp ->
+  bracket (openFd fp SPI.WriteOnly [SPDF.oTrunc] Nothing) (SPI.closeFd) $ \fd -> 
+    void $ SPB.fdWrite fd bs
+
+
+-- |Append a given ByteString to a file.
+-- The file must exist. Follows symlinks.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+appendFile :: Path Abs -> ByteString -> IO ()
+appendFile p bs = withAbsPath p $ \fp ->
+  bracket (openFd fp SPI.WriteOnly [SPDF.oAppend] Nothing)
+          (SPI.closeFd) $ \fd -> void $ SPB.fdWrite fd bs



@@ -828,6 +1006,8 @@ newDirPerms
 -- |Gets all filenames of the given directory. This excludes "." and "..".
 -- This version does not follow symbolic links.
 --
+-- The contents are not sorted and there is no guarantee on the ordering.
+--
 -- Throws:
 --
 --     - `NoSuchThing` if directory does not exist
--- a/src/HPath/IO/Errors.hs
+++ b/src/HPath/IO/Errors.hs
@@ -1,7 +1,7 @@
 -- |
 -- Module      :  HPath.IO.Errors
 -- Copyright   :  © 2016 Julian Ospald
-- License     :  GPL-2
+-- License     :  BSD3
 --
 -- Maintainer  :  Julian Ospald <hasufell@posteo.de>
 -- Stability   :  experimental
@@ -16,23 +16,20 @@ module HPath.IO.Errors
  (
  -- * Types
    HPathIOException(..)
+  , RecursiveFailureHint(..)

  -- * Exception identifiers
-  , isFileDoesNotExist
-  , isDirDoesNotExist
  , isSameFile
  , isDestinationInSource
-  , isFileDoesExist
-  , isDirDoesExist
-  , isInvalidOperation
-  , isCan'tOpenDirectory
-  , isCopyFailed
+  , isRecursiveFailure
+  , isReadContentsFailed
+  , isCreateDirFailed
+  , isCopyFileFailed
+  , isRecreateSymlinkFailed

  -- * Path based functions
  , throwFileDoesExist
  , throwDirDoesExist
-  , throwFileDoesNotExist
-  , throwDirDoesNotExist
  , throwSameFile
  , sameFile
  , throwDestinationInSource
@@ -40,7 +37,6 @@ module HPath.IO.Errors
  , doesDirectoryExist
  , isWritable
  , canOpenDirectory
-  , throwCantOpenDirectory

  -- * Error handling functions
  , catchErrno
@@ -62,6 +58,10 @@ import Control.Monad
    forM
  , when
  )
+import Control.Monad.IfElse
+  (
+    whenM
+  )
 import Data.ByteString
  (
    ByteString
@@ -70,11 +70,10 @@ import Data.ByteString.UTF8
  (
    toString
  )
-import Data.Data
-  (
-    Data(..)
-  )
 import Data.Typeable
+  (
+    Typeable
+  )
 import Foreign.C.Error
  (
    getErrno
@@ -89,11 +88,12 @@ import {-# SOURCE #-} HPath.IO
  (
    canonicalizePath
  )
-import HPath.IO.Utils
 import System.IO.Error
  (
-    catchIOError
+    alreadyExistsErrorType
+  , catchIOError
  , ioeGetErrorType
+  , mkIOError
  )

 import qualified System.Posix.Directory.ByteString as PFD
@@ -105,40 +105,36 @@ import System.Posix.Files.ByteString
 import qualified System.Posix.Files.ByteString as PF


-data HPathIOException = FileDoesNotExist ByteString
-                      | DirDoesNotExist ByteString
-                      | SameFile ByteString ByteString
+-- |Additional generic IO exceptions that the posix functions
+-- do not provide.
+data HPathIOException = SameFile ByteString ByteString
                      | DestinationInSource ByteString ByteString
-                      | FileDoesExist ByteString
-                      | DirDoesExist ByteString
-                      | InvalidOperation String
-                      | Can'tOpenDirectory ByteString
-                      | CopyFailed String
-  deriving (Typeable, Eq, Data)
+                      | RecursiveFailure [(RecursiveFailureHint, IOException)]
+  deriving (Eq, Show, Typeable)


-instance Show HPathIOException where
-  show (FileDoesNotExist fp) = "File does not exist:" ++ toString fp
-  show (DirDoesNotExist fp) = "Directory does not exist: "
-                              ++ toString fp
-  show (SameFile fp1 fp2) = toString fp1
-                            ++ " and " ++ toString fp2
-                            ++ " are the same file!"
-  show (DestinationInSource fp1 fp2) = toString fp1
-                                       ++ " is contained in "
-                                       ++ toString fp2
-  show (FileDoesExist fp) = "File does exist: " ++ toString fp
-  show (DirDoesExist fp) = "Directory does exist: " ++ toString fp
-  show (InvalidOperation str) = "Invalid operation: " ++ str
-  show (Can'tOpenDirectory fp) = "Can't open directory: "
-                                 ++ toString fp
-  show (CopyFailed str) = "Copying failed: " ++ str
-
+-- |A type for giving failure hints on recursive failure, which allows
+-- to programmatically make choices without examining
+-- the weakly typed I/O error attributes (like `ioeGetFileName`).
+--
+-- The first argument to the data constructor is always the
+-- source and the second the destination.
+data RecursiveFailureHint = ReadContentsFailed    (Path Abs) (Path Abs)
+                          | CreateDirFailed       (Path Abs) (Path Abs)
+                          | CopyFileFailed        (Path Abs) (Path Abs)
+                          | RecreateSymlinkFailed (Path Abs) (Path Abs)
+  deriving (Eq, Show)


 instance Exception HPathIOException


+toConstr :: HPathIOException -> String
+toConstr SameFile {}            = "SameFile"
+toConstr DestinationInSource {} = "DestinationInSource"
+toConstr RecursiveFailure {}    = "RecursiveFailure"
+
+



@@ -146,16 +142,23 @@ instance Exception HPathIOException
    --[ Exception identifiers ]--
    -----------------------------

-isFileDoesNotExist, isDirDoesNotExist, isSameFile, isDestinationInSource, isFileDoesExist, isDirDoesExist, isInvalidOperation, isCan'tOpenDirectory, isCopyFailed :: HPathIOException -> Bool
-isFileDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr FileDoesNotExist{}
-isDirDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr DirDoesNotExist{}
+
+isSameFile, isDestinationInSource, isRecursiveFailure :: HPathIOException -> Bool
 isSameFile ex = toConstr (ex :: HPathIOException) == toConstr SameFile{}
 isDestinationInSource ex = toConstr (ex :: HPathIOException) == toConstr DestinationInSource{}
-isFileDoesExist ex = toConstr (ex :: HPathIOException) == toConstr FileDoesExist{}
-isDirDoesExist ex = toConstr (ex :: HPathIOException) == toConstr DirDoesExist{}
-isInvalidOperation ex = toConstr (ex :: HPathIOException) == toConstr InvalidOperation{}
-isCan'tOpenDirectory ex = toConstr (ex :: HPathIOException) == toConstr Can'tOpenDirectory{}
-isCopyFailed ex = toConstr (ex :: HPathIOException) == toConstr CopyFailed{}
+isRecursiveFailure ex = toConstr (ex :: HPathIOException) == toConstr RecursiveFailure{}
+
+
+isReadContentsFailed, isCreateDirFailed, isCopyFileFailed, isRecreateSymlinkFailed ::RecursiveFailureHint -> Bool
+isReadContentsFailed ReadContentsFailed{} = True
+isReadContentsFailed _ = False
+isCreateDirFailed CreateDirFailed{} = True
+isCreateDirFailed _ = False
+isCopyFileFailed CopyFileFailed{} = True
+isCopyFileFailed _ = False
+isRecreateSymlinkFailed RecreateSymlinkFailed{} = True
+isRecreateSymlinkFailed _ = False
+



@@ -165,28 +168,28 @@ isCopyFailed ex = toConstr (ex :: HPathIOException) == toConstr CopyFailed{}
    ----------------------------


+-- |Throws `AlreadyExists` `IOError` if file exists.
 throwFileDoesExist :: Path Abs -> IO ()
 throwFileDoesExist fp =
-  whenM (doesFileExist fp) (throwIO . FileDoesExist
-                                    . fromAbs $ fp)
+  whenM (doesFileExist fp)
+        (ioError . mkIOError
+                     alreadyExistsErrorType
+                     "File already exists"
+                     Nothing
+                   $ (Just (toString $ fromAbs fp))
+        )


+-- |Throws `AlreadyExists` `IOError` if directory exists.
 throwDirDoesExist :: Path Abs -> IO ()
 throwDirDoesExist fp =
-  whenM (doesDirectoryExist fp) (throwIO . DirDoesExist
-                                         . fromAbs $ fp)
-
-
-throwFileDoesNotExist :: Path Abs -> IO ()
-throwFileDoesNotExist fp =
-  unlessM (doesFileExist fp) (throwIO . FileDoesNotExist
-                                      . fromAbs $ fp)
-
-
-throwDirDoesNotExist :: Path Abs -> IO ()
-throwDirDoesNotExist fp =
-  unlessM (doesDirectoryExist fp) (throwIO . DirDoesNotExist
-                                           . fromAbs $ fp)
+  whenM (doesDirectoryExist fp)
+        (ioError . mkIOError
+                     alreadyExistsErrorType
+                     "Directory already exists"
+                     Nothing
+                   $ (Just (toString $ fromAbs fp))
+        )


 -- |Uses `isSameFile` and throws `SameFile` if it returns True.
@@ -271,13 +274,6 @@ canOpenDirectory fp =
    return True


-- |Throws a `Can'tOpenDirectory` HPathIOException if the directory at the given
-- path cannot be opened.
-throwCantOpenDirectory :: Path Abs -> IO ()
-throwCantOpenDirectory fp =
-  unlessM (canOpenDirectory fp)
-          (throwIO . Can'tOpenDirectory . fromAbs $ fp)
-


    --------------------------------
@@ -357,3 +353,4 @@ reactOnError a ios fmios =
                                else y)
               (throwIO ex)
               fmios
+
--- a/src/HPath/IO/Utils.hs
+++ b/src/HPath/IO/Utils.hs
@@ -1,32 +0,0 @@
-- |
-- Module      :  HPath.IO.Utils
-- Copyright   :  © 2016 Julian Ospald
-- License     :  GPL-2
--
-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
-- Stability   :  experimental
-- Portability :  portable
--
-- Random and general IO/monad utilities.
-
-
-module HPath.IO.Utils where
-
-
-import Control.Monad
-  (
-    when
-  , unless
-  )
-
-
-- |If the value of the first argument is True, then execute the action
-- provided in the second argument, otherwise do nothing.
-whenM :: Monad m => m Bool -> m () -> m ()
-whenM mb a = mb >>= (`when` a)
-
-
-- |If the value of the first argument is False, then execute the action
-- provided in the second argument, otherwise do nothing.
-unlessM :: Monad m => m Bool -> m () -> m ()
-unlessM mb a = mb >>= (`unless` a)
--- a/src/System/Posix/Directory/Traversals.hs
+++ b/src/System/Posix/Directory/Traversals.hs
@@ -10,6 +10,7 @@
 -- Traversal and read operations on directories.


+{-# LANGUAGE CPP #-}
 {-# LANGUAGE ForeignFunctionInterface #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PackageImports #-}
@@ -37,7 +38,10 @@ module System.Posix.Directory.Traversals (
 , realpath
 ) where

-import Control.Applicative
+
+#if __GLASGOW_HASKELL__ < 710
+import Control.Applicative ((<$>))
+#endif
 import Control.Monad
 import System.Posix.FilePath ((</>))
 import System.Posix.Directory.Foreign
--- a/test/HPath/IO/AppendFileSpec.hs
+++ b/test/HPath/IO/AppendFileSpec.hs
@@ -0,0 +1,109 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.AppendFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import System.Process
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "AppendFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "BLKASL"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.appendFile" $ do
+
+    -- successes --
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" "blahfaselllll"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllll"
+
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" "gagagaga"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllllgagagaga"
+
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" ""
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllllgagagaga"
+
+    it "appendFile file without content, everything clear" $ do
+      appendFile' "fileWithoutContent" "blahfaselllll"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "appendFile, everything clear" $ do
+      appendFile' "fileWithoutContent" "gagagaga"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllllgagagaga"
+
+    it "appendFile symlink, everything clear" $ do
+      appendFile' "inputFileSymL" "blahfaselllll"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "BLKASLblahfaselllllgagagagablahfaselllll"
+
+    it "appendFile symlink, everything clear" $ do
+      appendFile' "inputFileSymL" "gagagaga"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "BLKASLblahfaselllllgagagagablahfaselllllgagagaga"
+
+
+    -- posix failures --
+    it "appendFile to dir, inappropriate type" $ do
+      appendFile' "alreadyExistsD" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "appendFile, no permissions to file" $ do
+      appendFile' "noPerms" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "appendFile, no permissions to file" $ do
+      appendFile' "noPermsD/inputFile" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "appendFile, file does not exist" $ do
+      appendFile' "gaga" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)
--- a/test/HPath/IO/CanonicalizePathSpec.hs
+++ b/test/HPath/IO/CanonicalizePathSpec.hs
@@ -13,12 +13,15 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)




+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CanonicalizePathSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
  createRegularFile' "file"
@@ -37,7 +40,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.canonicalizePath" $ do

    -- successes --
--- a/test/HPath/IO/CopyDirRecursiveCollectFailuresSpec.hs
+++ b/test/HPath/IO/CopyDirRecursiveCollectFailuresSpec.hs
@@ -0,0 +1,247 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.CopyDirRecursiveCollectFailuresSpec where
+
+
+import Test.Hspec
+import Data.List (sort)
+import HPath.IO
+import HPath.IO.Errors
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import System.Exit
+import System.Process
+import Utils
+import qualified Data.ByteString as BS
+import Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveCollectFailuresSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createRegularFile' "wrongInput"
+  createSymlink' "wrongInputSymL" "inputDir/"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+
+  createDir' "inputDir"
+  createDir' "inputDir/bar"
+  createDir' "inputDir/foo"
+  createRegularFile' "inputDir/foo/inputFile1"
+  createRegularFile' "inputDir/inputFile2"
+  createRegularFile' "inputDir/bar/inputFile3"
+  writeFile' "inputDir/foo/inputFile1" "SDAADSdsada"
+  writeFile' "inputDir/inputFile2" "Blahfaselgagaga"
+  writeFile' "inputDir/bar/inputFile3"
+    "fdfdssdffsd3223sasdasdasdadasasddasdasdasasd4"
+
+  createDir' "inputDir1"
+  createDir' "inputDir1/foo2"
+  createDir' "inputDir1/foo2/foo3"
+  createDir' "inputDir1/foo2/foo4"
+  createRegularFile' "inputDir1/foo2/inputFile1"
+  createRegularFile' "inputDir1/foo2/inputFile2"
+  createRegularFile' "inputDir1/foo2/inputFile3"
+  createRegularFile' "inputDir1/foo2/foo4/inputFile4"
+  createRegularFile' "inputDir1/foo2/foo4/inputFile6"
+  createRegularFile' "inputDir1/foo2/foo3/inputFile5"
+  noPerms "inputDir1/foo2/foo3"
+
+  createDir' "outputDir1"
+  createDir' "outputDir1/foo2"
+  createDir' "outputDir1/foo2/foo4"
+  createDir' "outputDir1/foo2/foo4/inputFile4"
+  createRegularFile' "outputDir1/foo2/foo4/inputFile6"
+  noPerms "outputDir1/foo2/foo4/inputFile4"
+  noPerms "outputDir1/foo2/foo4"
+
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+
+  normalDirPerms "inputDir1/foo2/foo3"
+  deleteFile' "inputDir1/foo2/foo4/inputFile4"
+  deleteFile' "inputDir1/foo2/foo4/inputFile6"
+  deleteFile' "inputDir1/foo2/inputFile1"
+  deleteFile' "inputDir1/foo2/inputFile2"
+  deleteFile' "inputDir1/foo2/inputFile3"
+  deleteFile' "inputDir1/foo2/foo3/inputFile5"
+  deleteDir' "inputDir1/foo2/foo3"
+  deleteDir' "inputDir1/foo2/foo4"
+  deleteDir' "inputDir1/foo2"
+  deleteDir' "inputDir1"
+
+  normalDirPerms "outputDir1/foo2/foo4"
+  normalDirPerms "outputDir1/foo2/foo4/inputFile4"
+  deleteFile' "outputDir1/foo2/foo4/inputFile6"
+  deleteDir' "outputDir1/foo2/foo4/inputFile4"
+  deleteDir' "outputDir1/foo2/foo4"
+  deleteDir' "outputDir1/foo2"
+  deleteDir' "outputDir1"
+
+  deleteFile' "alreadyExists"
+  deleteFile' "wrongInput"
+  deleteFile' "wrongInputSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+  deleteFile' "inputDir/foo/inputFile1"
+  deleteFile' "inputDir/inputFile2"
+  deleteFile' "inputDir/bar/inputFile3"
+  deleteDir' "inputDir/foo"
+  deleteDir' "inputDir/bar"
+  deleteDir' "inputDir"
+
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyDirRecursive" $ do
+
+    -- successes --
+    it "copyDirRecursive (Strict, CollectFailures), all fine and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+      (system $ "diff -r --no-dereference "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+    -- posix failures --
+    it "copyDirRecursive (Strict, CollectFailures), source directory does not exist" $
+      copyDirRecursive' "doesNotExist"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyDirRecursive (Strict, CollectFailures), cannot open source dir" $
+      copyDirRecursive' "noPerms/inputDir"
+                        "foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+
+    -- custom failures
+    it "copyDirRecursive (Overwrite, CollectFailures), various failures" $ do
+      copyDirRecursive' "inputDir1/foo2"
+                        "outputDir1/foo2"
+                        Overwrite
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure ex@[_, _]) ->
+          any (\(h, e) -> ioeGetErrorType e == InappropriateType
+                          && isCopyFileFailed h) ex &&
+          any (\(h, e) -> ioeGetErrorType e == PermissionDenied
+                          && isReadContentsFailed h) ex)
+      normalDirPerms "outputDir1/foo2/foo4"
+      normalDirPerms "outputDir1/foo2/foo4/inputFile4"
+      c <- allDirectoryContents' "outputDir1"
+      tmpDir' <- getRawTmpDir
+      let shouldC = (fmap (\x -> tmpDir' `BS.append` x)
+                          ["outputDir1"
+                          ,"outputDir1/foo2"
+                          ,"outputDir1/foo2/inputFile1"
+                          ,"outputDir1/foo2/inputFile2"
+                          ,"outputDir1/foo2/inputFile3"
+                          ,"outputDir1/foo2/foo4"
+                          ,"outputDir1/foo2/foo4/inputFile6"
+                          ,"outputDir1/foo2/foo4/inputFile4"])
+      deleteFile' "outputDir1/foo2/inputFile1"
+      deleteFile' "outputDir1/foo2/inputFile2"
+      deleteFile' "outputDir1/foo2/inputFile3"
+      sort c `shouldBe` sort shouldC
+
+
+    it "copyDirRecursive (Strict, CollectFailures), no write permission on output dir" $
+      copyDirRecursive' "inputDir"
+                        "noWritePerm/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(CreateDirFailed{}, e)]) -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive (Strict, CollectFailures), cannot open output dir" $
+      copyDirRecursive' "inputDir"
+                        "noPerms/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isRecursiveFailure
+
+    it "copyDirRecursive (Strict, CollectFailures), destination dir already exists" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(CreateDirFailed{}, e)]) -> ioeGetErrorType e == AlreadyExists)
+
+    it "copyDirRecursive (Strict, CollectFailures), destination already exists and is a file" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExists"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isRecursiveFailure
+
+    it "copyDirRecursive (Strict, CollectFailures), wrong input (regular file)" $
+      copyDirRecursive' "wrongInput"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(ReadContentsFailed{}, e)]) -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive (Strict, CollectFailures), wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(ReadContentsFailed{}, e)]) -> ioeGetErrorType e == InvalidArgument)
+
+    it "copyDirRecursive (Strict, CollectFailures), destination in source" $
+      copyDirRecursive' "inputDir"
+                        "inputDir/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isDestinationInSource
+
+    it "copyDirRecursive (Strict, CollectFailures), destination and source same directory" $
+      copyDirRecursive' "inputDir"
+                        "inputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isSameFile
+
+
--- a/test/HPath/IO/CopyDirRecursiveOverwriteSpec.hs
+++ b/test/HPath/IO/CopyDirRecursiveOverwriteSpec.hs
@@ -5,6 +5,7 @@ module HPath.IO.CopyDirRecursiveOverwriteSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -17,11 +18,16 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+import Data.ByteString.UTF8 (toString)



+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveOverwriteSpec"
+  createTmpDir
+
+
 setupFiles :: IO ()
 setupFiles = do
  createRegularFile' "alreadyExists"
@@ -81,89 +87,116 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyDirRecursiveOverwrite" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyDirRecursive" $ do

    -- successes --
-    it "copyDirRecursiveOverwrite, all fine" $ do
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "outputDir"
+    it "copyDirRecursive (Overwrite, FailEarly), all fine" $ do
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
      removeDirIfExists "outputDir"

-    it "copyDirRecursiveOverwrite, all fine and compare" $ do
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "outputDir"
+    it "copyDirRecursive (Overwrite, FailEarly), all fine and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "outputDir")
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir")
        `shouldReturn` ExitSuccess
      removeDirIfExists "outputDir"

-    it "copyDirRecursiveOverwrite, destination dir already exists" $ do
+    it "copyDirRecursive (Overwrite, FailEarly), destination dir already exists" $ do
+      tmpDir' <- getRawTmpDir
      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "alreadyExistsD")
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD")
        `shouldReturn` (ExitFailure 1)
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "alreadyExistsD"
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Overwrite
+                        FailEarly
      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "alreadyExistsD")
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD")
        `shouldReturn` ExitSuccess
      removeDirIfExists "outputDir"

+
    -- posix failures --
-    it "copyDirRecursiveOverwrite, source directory does not exist" $
-      copyDirRecursiveOverwrite' "doesNotExist"
-                                 "outputDir"
+    it "copyDirRecursive, source directory does not exist" $
+      copyDirRecursive' "doesNotExist"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "copyDirRecursiveOverwrite, no write permission on output dir" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "noWritePerm/foo"
+    it "copyDirRecursive, no write permission on output dir" $
+      copyDirRecursive' "inputDir"
+                        "noWritePerm/foo"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursiveOverwrite, cannot open output dir" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "noPerms/foo"
+    it "copyDirRecursive, cannot open output dir" $
+      copyDirRecursive' "inputDir"
+                        "noPerms/foo"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursiveOverwrite, cannot open source dir" $
-      copyDirRecursiveOverwrite' "noPerms/inputDir"
-                                 "foo"
+    it "copyDirRecursive, cannot open source dir" $
+      copyDirRecursive' "noPerms/inputDir"
+                        "foo"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursiveOverwrite, destination already exists and is a file" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "alreadyExists"
+    it "copyDirRecursive, destination already exists and is a file" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExists"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

-    it "copyDirRecursiveOverwrite, wrong input (regular file)" $
-      copyDirRecursiveOverwrite' "wrongInput"
-                                 "outputDir"
+    it "copyDirRecursive, wrong input (regular file)" $
+      copyDirRecursive' "wrongInput"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

-    it "copyDirRecursiveOverwrite, wrong input (symlink to directory)" $
-      copyDirRecursiveOverwrite' "wrongInputSymL"
-                                 "outputDir"
+    it "copyDirRecursive, wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

    -- custom failures
-    it "copyDirRecursiveOverwrite, destination in source" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "inputDir/foo"
+    it "copyDirRecursive (Overwrite, FailEarly), destination in source" $
+      copyDirRecursive' "inputDir"
+                        "inputDir/foo"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        isDestinationInSource

-    it "copyDirRecursiveOverwrite, destination and source same directory" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "inputDir"
+    it "copyDirRecursive (Overwrite, FailEarly), destination and source same directory" $
+      copyDirRecursive' "inputDir"
+                        "inputDir"
+                        Overwrite
+                        FailEarly
        `shouldThrow`
        isSameFile
--- a/test/HPath/IO/CopyDirRecursiveSpec.hs
+++ b/test/HPath/IO/CopyDirRecursiveSpec.hs
@@ -5,6 +5,7 @@ module HPath.IO.CopyDirRecursiveSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -17,12 +18,14 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
-
+import Data.ByteString.UTF8 (toString)



+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveSpec"
+  createTmpDir

 setupFiles :: IO ()
 setupFiles = do
@@ -69,82 +72,109 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.copyDirRecursive" $ do

    -- successes --
-    it "copyDirRecursive, all fine" $ do
+    it "copyDirRecursive (Strict, FailEarly), all fine" $ do
      copyDirRecursive' "inputDir"
                        "outputDir"
+                        Strict
+                        FailEarly
      removeDirIfExists "outputDir"

-    it "copyDirRecursive, all fine and compare" $ do
+    it "copyDirRecursive (Strict, FailEarly), all fine and compare" $ do
+      tmpDir' <- getRawTmpDir
      copyDirRecursive' "inputDir"
                        "outputDir"
+                        Strict
+                        FailEarly
      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "outputDir")
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir")
        `shouldReturn` ExitSuccess
      removeDirIfExists "outputDir"

    -- posix failures --
-    it "copyDirRecursive, source directory does not exist" $
+    it "copyDirRecursive (Strict, FailEarly), source directory does not exist" $
      copyDirRecursive' "doesNotExist"
                        "outputDir"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "copyDirRecursive, no write permission on output dir" $
+    it "copyDirRecursive (Strict, FailEarly), no write permission on output dir" $
      copyDirRecursive' "inputDir"
                        "noWritePerm/foo"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursive, cannot open output dir" $
+    it "copyDirRecursive (Strict, FailEarly), cannot open output dir" $
      copyDirRecursive' "inputDir"
                        "noPerms/foo"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursive, cannot open source dir" $
+    it "copyDirRecursive (Strict, FailEarly), cannot open source dir" $
      copyDirRecursive' "noPerms/inputDir"
                        "foo"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyDirRecursive, destination dir already exists" $
+    it "copyDirRecursive (Strict, FailEarly), destination dir already exists" $
      copyDirRecursive' "inputDir"
                        "alreadyExistsD"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "copyDirRecursive, destination already exists and is a file" $
+    it "copyDirRecursive (Strict, FailEarly), destination already exists and is a file" $
      copyDirRecursive' "inputDir"
                        "alreadyExists"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "copyDirRecursive, wrong input (regular file)" $
+    it "copyDirRecursive (Strict, FailEarly), wrong input (regular file)" $
      copyDirRecursive' "wrongInput"
                        "outputDir"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

-    it "copyDirRecursive, wrong input (symlink to directory)" $
+    it "copyDirRecursive (Strict, FailEarly), wrong input (symlink to directory)" $
      copyDirRecursive' "wrongInputSymL"
                        "outputDir"
+                        Strict
+                        FailEarly
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

    -- custom failures
-    it "copyDirRecursive, destination in source" $
+    it "copyDirRecursive (Strict, FailEarly), destination in source" $
      copyDirRecursive' "inputDir"
                        "inputDir/foo"
+                        Strict
+                        FailEarly
        `shouldThrow`
        isDestinationInSource

-    it "copyDirRecursive, destination and source same directory" $
+    it "copyDirRecursive (Strict, FailEarly), destination and source same directory" $
      copyDirRecursive' "inputDir"
                        "inputDir"
+                        Strict
+                        FailEarly
        `shouldThrow`
        isSameFile
+
+
--- a/test/HPath/IO/CopyFileOverwriteSpec.hs
+++ b/test/HPath/IO/CopyFileOverwriteSpec.hs
@@ -4,6 +4,7 @@ module HPath.IO.CopyFileOverwriteSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -16,8 +17,14 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+import Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileOverwriteSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -51,79 +58,91 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyFileOverwrite" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyFile" $ do

    -- successes --
-    it "copyFileOverwrite, everything clear" $ do
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), everything clear" $ do
+      copyFile' "inputFile"
                "outputFile"
+                Overwrite
      removeFileIfExists "outputFile"

-    it "copyFileOverwrite, output file already exists, all clear" $ do
-      copyFile' "alreadyExists" "alreadyExists.bak"
-      copyFileOverwrite' "inputFile"
-                         "alreadyExists"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "alreadyExists")
+    it "copyFile (Overwrite), output file already exists, all clear" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "alreadyExists" "alreadyExists.bak" Strict
+      copyFile' "inputFile" "alreadyExists" Overwrite
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExists")
        `shouldReturn` ExitSuccess
      removeFileIfExists "alreadyExists"
-      copyFile' "alreadyExists.bak" "alreadyExists"
+      copyFile' "alreadyExists.bak" "alreadyExists" Strict
      removeFileIfExists "alreadyExists.bak"

-    it "copyFileOverwrite, and compare" $ do
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "inputFile"
                "outputFile"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "outputFile")
+                Overwrite
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
        `shouldReturn` ExitSuccess
      removeFileIfExists "outputFile"

+
    -- posix failures --
-    it "copyFileOverwrite, input file does not exist" $
-      copyFileOverwrite' "noSuchFile"
+    it "copyFile (Overwrite), input file does not exist" $
+      copyFile' "noSuchFile"
                "outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "copyFileOverwrite, no permission to write to output directory" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), no permission to write to output directory" $
+      copyFile' "inputFile"
                "outputDirNoWrite/outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFileOverwrite, cannot open output directory" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), cannot open output directory" $
+      copyFile' "inputFile"
                "noPerms/outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFileOverwrite, cannot open source directory" $
-      copyFileOverwrite' "noPerms/inputFile"
+    it "copyFile (Overwrite), cannot open source directory" $
+      copyFile' "noPerms/inputFile"
                "outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFileOverwrite, wrong input type (symlink)" $
-      copyFileOverwrite' "inputFileSymL"
+    it "copyFile (Overwrite), wrong input type (symlink)" $
+      copyFile' "inputFileSymL"
                "outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

-    it "copyFileOverwrite, wrong input type (directory)" $
-      copyFileOverwrite' "wrongInput"
+    it "copyFile (Overwrite), wrong input type (directory)" $
+      copyFile' "wrongInput"
                "outputFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

-    it "copyFileOverwrite, output file already exists and is a dir" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), output file already exists and is a dir" $
+      copyFile' "inputFile"
                "alreadyExistsD"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

    -- custom failures --
-    it "copyFileOverwrite, output and input are same file" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), output and input are same file" $
+      copyFile' "inputFile"
                "inputFile"
+                Overwrite
        `shouldThrow` isSameFile
--- a/test/HPath/IO/CopyFileSpec.hs
+++ b/test/HPath/IO/CopyFileSpec.hs
@@ -5,6 +5,7 @@ module HPath.IO.CopyFileSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -17,10 +18,15 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+import Data.ByteString.UTF8 (toString)


+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
  createRegularFile' "inputFile"
@@ -51,75 +57,87 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.copyFile" $ do

    -- successes --
-    it "copyFile, everything clear" $ do
+    it "copyFile (Strict), everything clear" $ do
      copyFile' "inputFile"
                "outputFile"
+                Strict
      removeFileIfExists "outputFile"

-    it "copyFile, and compare" $ do
+    it "copyFile (Strict), and compare" $ do
+      tmpDir' <- getRawTmpDir
      copyFile' "inputFile"
                "outputFile"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "outputFile")
+                Strict
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
        `shouldReturn` ExitSuccess
      removeFileIfExists "outputFile"

    -- posix failures --
-    it "copyFile, input file does not exist" $
+    it "copyFile (Strict), input file does not exist" $
      copyFile' "noSuchFile"
                "outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "copyFile, no permission to write to output directory" $
+    it "copyFile (Strict), no permission to write to output directory" $
      copyFile' "inputFile"
                "outputDirNoWrite/outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFile, cannot open output directory" $
+    it "copyFile (Strict), cannot open output directory" $
      copyFile' "inputFile"
                "noPerms/outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFile, cannot open source directory" $
+    it "copyFile (Strict), cannot open source directory" $
      copyFile' "noPerms/inputFile"
                "outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "copyFile, wrong input type (symlink)" $
+    it "copyFile (Strict), wrong input type (symlink)" $
      copyFile' "inputFileSymL"
                "outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

-    it "copyFile, wrong input type (directory)" $
+    it "copyFile (Strict), wrong input type (directory)" $
      copyFile' "wrongInput"
                "outputFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == InappropriateType)

-    it "copyFile, output file already exists" $
+    it "copyFile (Strict), output file already exists" $
      copyFile' "inputFile"
                "alreadyExists"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "copyFile, output file already exists and is a dir" $
+    it "copyFile (Strict), output file already exists and is a dir" $
      copyFile' "inputFile"
                "alreadyExistsD"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

    -- custom failures --
-    it "copyFile, output and input are same file" $
+    it "copyFile (Strict), output and input are same file" $
      copyFile' "inputFile"
                "inputFile"
+                Strict
        `shouldThrow`
        isSameFile
--- a/test/HPath/IO/CreateDirRecursiveSpec.hs
+++ b/test/HPath/IO/CreateDirRecursiveSpec.hs
@@ -0,0 +1,78 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CreateDirRecursiveSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirRecursiveSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createDir' "alreadyExists"
+  createRegularFile' "alreadyExistsF"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteDir' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
+  deleteFile' "alreadyExistsF"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.createDirRecursive" $ do
+
+    -- successes --
+    it "createDirRecursive, all fine" $ do
+      createDirRecursive' "newDir"
+      deleteDir' "newDir"
+
+    it "createDirRecursive, parent directories do not exist" $ do
+      createDirRecursive' "some/thing/dada"
+      deleteDir' "some/thing/dada"
+      deleteDir' "some/thing"
+      deleteDir' "some"
+
+    it "createDirRecursive, destination directory already exists" $
+      createDirRecursive' "alreadyExists"
+
+    -- posix failures --
+    it "createDirRecursive, destination already exists and is a file" $
+      createDirRecursive' "alreadyExistsF"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "createDirRecursive, can't write to output directory" $
+      createDirRecursive' "noWritePerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createDirRecursive, can't open output directory" $
+      createDirRecursive' "noPerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+
+
--- a/test/HPath/IO/CreateDirSpec.hs
+++ b/test/HPath/IO/CreateDirSpec.hs
@@ -13,10 +13,14 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)


+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
  createDir' "alreadyExists"
@@ -37,7 +41,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.createDir" $ do

    -- successes --
@@ -46,6 +50,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
      removeDirIfExists "newDir"

    -- posix failures --
+    it "createDir, parent directories do not exist" $
+      createDir' "some/thing/dada"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
    it "createDir, can't write to output directory" $
      createDir' "noWritePerms/newDir"
        `shouldThrow`
--- a/test/HPath/IO/CreateRegularFileSpec.hs
+++ b/test/HPath/IO/CreateRegularFileSpec.hs
@@ -13,10 +13,14 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)


+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateRegularFileSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
  createRegularFile' "alreadyExists"
@@ -25,8 +29,6 @@ setupFiles = do
  noPerms "noPerms"
  noWritableDirPerms "noWritePerms"

-
-
 cleanupFiles :: IO ()
 cleanupFiles = do
  normalDirPerms "noPerms"
@@ -37,7 +39,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.createRegularFile" $ do

    -- successes --
@@ -46,6 +48,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
      removeFileIfExists "newDir"

    -- posix failures --
+    it "createRegularFile, parent directories do not exist" $
+      createRegularFile' "some/thing/dada"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
    it "createRegularFile, can't write to destination directory" $
      createRegularFile' "noWritePerms/newDir"
        `shouldThrow`
--- a/test/HPath/IO/CreateSymlinkSpec.hs
+++ b/test/HPath/IO/CreateSymlinkSpec.hs
@@ -4,7 +4,6 @@ module HPath.IO.CreateSymlinkSpec where


 import Test.Hspec
-import HPath.IO.Errors
 import System.IO.Error
  (
    ioeGetErrorType
@@ -14,8 +13,12 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateSymlinkSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -37,7 +40,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.createSymlink" $ do

    -- successes --
@@ -46,6 +49,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
      removeFileIfExists "newSymL"

    -- posix failures --
+    it "createSymlink, parent directories do not exist" $
+      createSymlink' "some/thing/dada" "lala"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
    it "createSymlink, can't write to destination directory" $
      createSymlink' "noWritePerms/newDir" "lala"
        `shouldThrow`
--- a/test/HPath/IO/DeleteDirRecursiveSpec.hs
+++ b/test/HPath/IO/DeleteDirRecursiveSpec.hs
@@ -17,8 +17,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirRecursiveSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -46,7 +51,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.deleteDirRecursive" $ do

    -- successes --
--- a/test/HPath/IO/DeleteDirSpec.hs
+++ b/test/HPath/IO/DeleteDirSpec.hs
@@ -17,8 +17,14 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -46,7 +52,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.deleteDir" $ do

    -- successes --
--- a/test/HPath/IO/DeleteFileSpec.hs
+++ b/test/HPath/IO/DeleteFileSpec.hs
@@ -4,6 +4,7 @@ module HPath.IO.DeleteFileSpec where


 import Test.Hspec
+import HPath.IO
 import System.IO.Error
  (
    ioeGetErrorType
@@ -17,8 +18,12 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteFileSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -41,7 +46,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.deleteFile" $ do

    -- successes --
@@ -55,6 +60,7 @@ spec = before_ setupFiles $ after_ cleanupFiles $
    it "deleteFile, symlink, all fine" $ do
      recreateSymlink' "syml"
                       "testFile"
+                       Strict
      deleteFile' "testFile"
      getSymbolicLinkStatus "testFile"
        `shouldThrow`
--- a/test/HPath/IO/GetDirsFilesSpec.hs
+++ b/test/HPath/IO/GetDirsFilesSpec.hs
@@ -3,18 +3,10 @@
 module HPath.IO.GetDirsFilesSpec where


-import Control.Applicative
-  (
-    (<$>)
-  )
 import Data.List
  (
    sort
  )
-import Data.Maybe
-  (
-    fromJust
-  )
 import qualified HPath as P
 import HPath.IO
 import Test.Hspec
@@ -22,17 +14,17 @@ import System.IO.Error
  (
    ioeGetErrorType
  )
-import System.Posix.Env.ByteString
-  (
-    getEnv
-  )
 import GHC.IO.Exception
  (
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetDirsFilesSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -61,7 +53,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.getDirsFiles" $ do

    -- successes --
--- a/test/HPath/IO/GetFileTypeSpec.hs
+++ b/test/HPath/IO/GetFileTypeSpec.hs
@@ -14,8 +14,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetFileTypeSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -42,7 +47,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.getFileType" $ do

    -- successes --
--- a/test/HPath/IO/MoveFileOverwriteSpec.hs
+++ b/test/HPath/IO/MoveFileOverwriteSpec.hs
@@ -4,6 +4,7 @@ module HPath.IO.MoveFileOverwriteSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -14,8 +15,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "MoveFileOverwriteSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -45,65 +51,76 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.moveFileOverwrite" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.moveFile" $ do

    -- successes --
-    it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' "myFile"
-                         "movedFile"
+    it "moveFile (Overwrite), all fine" $
+      moveFile' "myFile"
+                "movedFile"
+                Overwrite

-    it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' "myFile"
-                         "dir/movedFile"
+    it "moveFile (Overwrite), all fine" $
+      moveFile' "myFile"
+                "dir/movedFile"
+                Overwrite

-    it "moveFileOverwrite, all fine on symlink" $
-      moveFileOverwrite' "myFileL"
-                         "movedFile"
+    it "moveFile (Overwrite), all fine on symlink" $
+      moveFile' "myFileL"
+                "movedFile"
+                Overwrite

-    it "moveFileOverwrite, all fine on directory" $
-      moveFileOverwrite' "dir"
-                         "movedFile"
+    it "moveFile (Overwrite), all fine on directory" $
+      moveFile' "dir"
+                "movedFile"
+                Overwrite

-    it "moveFileOverwrite, destination file already exists" $
-      moveFileOverwrite' "myFile"
-                         "alreadyExists"
+    it "moveFile (Overwrite), destination file already exists" $
+      moveFile' "myFile"
+                "alreadyExists"
+                Overwrite

    -- posix failures --
-    it "moveFileOverwrite, source file does not exist" $
-      moveFileOverwrite' "fileDoesNotExist"
-                         "movedFile"
+    it "moveFile (Overwrite), source file does not exist" $
+      moveFile' "fileDoesNotExist"
+                "movedFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "moveFileOverwrite, can't write to destination directory" $
-      moveFileOverwrite' "myFile"
-                         "noWritePerm/movedFile"
+    it "moveFile (Overwrite), can't write to destination directory" $
+      moveFile' "myFile"
+                "noWritePerm/movedFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "moveFileOverwrite, can't open destination directory" $
-      moveFileOverwrite' "myFile"
-                         "noPerms/movedFile"
+    it "moveFile (Overwrite), can't open destination directory" $
+      moveFile' "myFile"
+                "noPerms/movedFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "moveFileOverwrite, can't open source directory" $
-      moveFileOverwrite' "noPerms/myFile"
-                         "movedFile"
+    it "moveFile (Overwrite), can't open source directory" $
+      moveFile' "noPerms/myFile"
+                "movedFile"
+                Overwrite
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

    -- custom failures --
-    it "moveFileOverwrite, move from file to dir" $
-      moveFileOverwrite' "myFile"
-                         "alreadyExistsD"
-        `shouldThrow`
-        isDirDoesExist

-    it "moveFileOverwrite, source and dest are same file" $
-      moveFileOverwrite' "myFile"
-                         "myFile"
+    it "moveFile (Overwrite), move from file to dir" $
+      moveFile' "myFile"
+                "alreadyExistsD"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "moveFile (Overwrite), source and dest are same file" $
+      moveFile' "myFile"
+                "myFile"
+                Overwrite
        `shouldThrow`
        isSameFile
-
--- a/test/HPath/IO/MoveFileSpec.hs
+++ b/test/HPath/IO/MoveFileSpec.hs
@@ -4,6 +4,7 @@ module HPath.IO.MoveFileSpec where


 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -14,8 +15,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "MoveFileSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -47,67 +53,77 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.moveFile" $ do

    -- successes --
-    it "moveFile, all fine" $
+    it "moveFile (Strict), all fine" $
      moveFile' "myFile"
                "movedFile"
+                Strict

-    it "moveFile, all fine" $
+    it "moveFile (Strict), all fine" $
      moveFile' "myFile"
                "dir/movedFile"
+                Strict

-    it "moveFile, all fine on symlink" $
+    it "moveFile (Strict), all fine on symlink" $
      moveFile' "myFileL"
                "movedFile"
+                Strict

-    it "moveFile, all fine on directory" $
+    it "moveFile (Strict), all fine on directory" $
      moveFile' "dir"
                "movedFile"
+                Strict

    -- posix failures --
-    it "moveFile, source file does not exist" $
+    it "moveFile (Strict), source file does not exist" $
      moveFile' "fileDoesNotExist"
                "movedFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == NoSuchThing)

-    it "moveFile, can't write to destination directory" $
+    it "moveFile (Strict), can't write to destination directory" $
      moveFile' "myFile"
                "noWritePerm/movedFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "moveFile, can't open destination directory" $
+    it "moveFile (Strict), can't open destination directory" $
      moveFile' "myFile"
                "noPerms/movedFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "moveFile, can't open source directory" $
+    it "moveFile (Strict), can't open source directory" $
      moveFile' "noPerms/myFile"
                "movedFile"
+                Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

    -- custom failures --
-    it "moveFile, destination file already exists" $
+    it "moveFile (Strict), destination file already exists" $
      moveFile' "myFile"
                "alreadyExists"
+                Strict
        `shouldThrow`
-        isFileDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "moveFile, move from file to dir" $
+    it "moveFile (Strict), move from file to dir" $
      moveFile' "myFile"
                "alreadyExistsD"
+                Strict
        `shouldThrow`
-        isDirDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "moveFile, source and dest are same file" $
+    it "moveFile (Strict), source and dest are same file" $
      moveFile' "myFile"
                "myFile"
+                Strict
        `shouldThrow`
        isSameFile
-
--- a/test/HPath/IO/ReadFileEOFSpec.hs
+++ b/test/HPath/IO/ReadFileEOFSpec.hs
@@ -0,0 +1,86 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.ReadFileEOFSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import System.Process
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "ReadFileEOFSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.readFileEOF" $ do
+
+    -- successes --
+    it "readFileEOF (Strict) file with content, everything clear" $ do
+      out <- readFileEOF' "fileWithContent"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFileEOF (Strict) symlink, everything clear" $ do
+      out <- readFileEOF' "inputFileSymL"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFileEOF (Strict) empty file, everything clear" $ do
+      out <- readFileEOF' "fileWithoutContent"
+      out `shouldBe` ""
+
+
+    -- posix failures --
+    it "readFileEOF (Strict) directory, wrong file type" $ do
+      readFileEOF' "alreadyExistsD"
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "readFileEOF (Strict) file, no permissions" $ do
+      readFileEOF' "noPerms"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFileEOF (Strict) file, no permissions on dir" $ do
+      readFileEOF' "noPermsD/inputFile"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFileEOF (Strict) file, no such file" $ do
+      readFileEOF' "lalala"
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)
--- a/test/HPath/IO/ReadFileSpec.hs
+++ b/test/HPath/IO/ReadFileSpec.hs
@@ -0,0 +1,86 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.ReadFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import System.Process
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "ReadFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.readFile" $ do
+
+    -- successes --
+    it "readFile (Strict) file with content, everything clear" $ do
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFile (Strict) symlink, everything clear" $ do
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFile (Strict) empty file, everything clear" $ do
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` ""
+
+
+    -- posix failures --
+    it "readFile (Strict) directory, wrong file type" $ do
+      readFile' "alreadyExistsD"
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "readFile (Strict) file, no permissions" $ do
+      readFile' "noPerms"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFile (Strict) file, no permissions on dir" $ do
+      readFile' "noPermsD/inputFile"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFile (Strict) file, no such file" $ do
+      readFile' "lalala"
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)
--- a/test/HPath/IO/RecreateSymlinkOverwriteSpec.hs
+++ b/test/HPath/IO/RecreateSymlinkOverwriteSpec.hs
@@ -0,0 +1,139 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.RecreateSymlinkOverwriteSpec where
+
+
+-- TODO: exception if destination exists but is not a file + `OverWrite` CopyMode
+
+
+import Test.Hspec
+import HPath.IO
+import HPath.IO.Errors
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RecreateSymlinkOverwriteSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  createDir' "alreadyExistsD2"
+  createRegularFile' "alreadyExistsD2/lala"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteFile' "alreadyExistsD2/lala"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "alreadyExistsD2"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.recreateSymlink" $ do
+
+    -- successes --
+    it "recreateSymLink (Overwrite), all fine" $ do
+      recreateSymlink' "myFileL"
+                       "movedFile"
+                       Overwrite
+      removeFileIfExists "movedFile"
+
+    it "recreateSymLink (Overwrite), all fine" $ do
+      recreateSymlink' "myFileL"
+                       "dir/movedFile"
+                       Overwrite
+      removeFileIfExists "dir/movedFile"
+
+    it "recreateSymLink (Overwrite), destination file already exists" $
+      recreateSymlink' "myFileL"
+                       "alreadyExists"
+                       Overwrite
+
+    it "recreateSymLink (Overwrite), destination already exists and is an empty dir" $ do
+      recreateSymlink' "myFileL"
+                       "alreadyExistsD"
+                       Overwrite
+      deleteFile' "alreadyExistsD"
+      createDir' "alreadyExistsD"
+
+    -- posix failures --
+    it "recreateSymLink (Overwrite), destination already exists and is a non-empty dir" $
+      recreateSymlink' "myFileL"
+                       "alreadyExistsD2"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == UnsatisfiedConstraints)
+
+    it "recreateSymLink (Overwrite), wrong input type (file)" $
+      recreateSymlink' "myFile"
+                       "movedFile"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "recreateSymLink (Overwrite), wrong input type (directory)" $
+      recreateSymlink' "dir"
+                       "movedFile"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "recreateSymLink (Overwrite), can't write to destination directory" $
+      recreateSymlink' "myFileL"
+                       "noWritePerm/movedFile"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "recreateSymLink (Overwrite), can't open destination directory" $
+      recreateSymlink' "myFileL"
+                       "noPerms/movedFile"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "recreateSymLink (Overwrite), can't open source directory" $
+      recreateSymlink' "noPerms/myFileL"
+                       "movedFile"
+                       Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    -- custom failures --
+    it "recreateSymLink (Overwrite), source and destination are the same file" $
+      recreateSymlink' "myFileL"
+                       "myFileL"
+                       Overwrite
+        `shouldThrow`
+        isSameFile
+
--- a/test/HPath/IO/RecreateSymlinkSpec.hs
+++ b/test/HPath/IO/RecreateSymlinkSpec.hs
@@ -3,7 +3,10 @@
 module HPath.IO.RecreateSymlinkSpec where


+
+
 import Test.Hspec
+import HPath.IO
 import HPath.IO.Errors
 import System.IO.Error
  (
@@ -14,8 +17,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RecreateSymlinkSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -46,67 +54,77 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.recreateSymlink" $ do

    -- successes --
-    it "recreateSymLink, all fine" $ do
+    it "recreateSymLink (Strict), all fine" $ do
      recreateSymlink' "myFileL"
                       "movedFile"
+                       Strict
      removeFileIfExists "movedFile"

-    it "recreateSymLink, all fine" $ do
+    it "recreateSymLink (Strict), all fine" $ do
      recreateSymlink' "myFileL"
                       "dir/movedFile"
+                       Strict
      removeFileIfExists "dir/movedFile"

    -- posix failures --
-    it "recreateSymLink, wrong input type (file)" $
+    it "recreateSymLink (Strict), wrong input type (file)" $
      recreateSymlink' "myFile"
                       "movedFile"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

-    it "recreateSymLink, wrong input type (directory)" $
+    it "recreateSymLink (Strict), wrong input type (directory)" $
      recreateSymlink' "dir"
                       "movedFile"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == InvalidArgument)

-    it "recreateSymLink, can't write to destination directory" $
+    it "recreateSymLink (Strict), can't write to destination directory" $
      recreateSymlink' "myFileL"
                       "noWritePerm/movedFile"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "recreateSymLink, can't open destination directory" $
+    it "recreateSymLink (Strict), can't open destination directory" $
      recreateSymlink' "myFileL"
                       "noPerms/movedFile"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "recreateSymLink, can't open source directory" $
+    it "recreateSymLink (Strict), can't open source directory" $
      recreateSymlink' "noPerms/myFileL"
                       "movedFile"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == PermissionDenied)

-    it "recreateSymLink, destination file already exists" $
+    it "recreateSymLink (Strict), destination file already exists" $
      recreateSymlink' "myFileL"
                       "alreadyExists"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

-    it "recreateSymLink, destination already exists and is a dir" $
+    it "recreateSymLink (Strict), destination already exists and is a dir" $
      recreateSymlink' "myFileL"
                       "alreadyExistsD"
+                       Strict
        `shouldThrow`
        (\e -> ioeGetErrorType e == AlreadyExists)

    -- custom failures --
-    it "recreateSymLink, source and destination are the same file" $
+    it "recreateSymLink (Strict), source and destination are the same file" $
      recreateSymlink' "myFileL"
                       "myFileL"
+                       Strict
        `shouldThrow`
        isSameFile

--- a/test/HPath/IO/RenameFileSpec.hs
+++ b/test/HPath/IO/RenameFileSpec.hs
@@ -14,8 +14,13 @@ import GHC.IO.Exception
    IOErrorType(..)
  )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RenameFileSpec"
+  createTmpDir


 setupFiles :: IO ()
@@ -46,7 +51,7 @@ cleanupFiles = do


 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
  describe "HPath.IO.renameFile" $ do

    -- successes --
@@ -96,13 +101,13 @@ spec = before_ setupFiles $ after_ cleanupFiles $
      renameFile' "myFile"
                  "alreadyExists"
        `shouldThrow`
-        isFileDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)

    it "renameFile, move from file to dir" $
      renameFile' "myFile"
                  "alreadyExistsD"
        `shouldThrow`
-        isDirDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)

    it "renameFile, source and dest are same file" $
      renameFile' "myFile"
--- a/test/HPath/IO/WriteFileSpec.hs
+++ b/test/HPath/IO/WriteFileSpec.hs
@@ -0,0 +1,109 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.WriteFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import System.Process
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "WriteFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "BLKASL"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.writeFile" $ do
+
+    -- successes --
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" "blahfaselllll"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" "gagagaga"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "gagagaga"
+
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" ""
+      out <- readFile' "fileWithContent"
+      out `shouldBe` ""
+
+    it "writeFile file without content, everything clear" $ do
+      writeFile' "fileWithoutContent" "blahfaselllll"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile, everything clear" $ do
+      writeFile' "fileWithoutContent" "gagagaga"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "gagagaga"
+
+    it "writeFile symlink, everything clear" $ do
+      writeFile' "inputFileSymL" "blahfaselllll"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile symlink, everything clear" $ do
+      writeFile' "inputFileSymL" "gagagaga"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "gagagaga"
+
+
+    -- posix failures --
+    it "writeFile to dir, inappropriate type" $ do
+      writeFile' "alreadyExistsD" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "writeFile, no permissions to file" $ do
+      writeFile' "noPerms" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "writeFile, no permissions to file" $ do
+      writeFile' "noPermsD/inputFile" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "writeFile, file does not exist" $ do
+      writeFile' "gaga" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -14,10 +14,6 @@ main :: IO ()
 main =
  hspecWith
    defaultConfig { configFormatter = Just progress }
-    $ before_ up
-    $ after_ down
+    $ beforeAll_ createBaseTmpDir
+    $ afterAll_ deleteBaseTmpDir
    $ Spec.spec
-  where
-    up = createTmpDir
-    down = deleteTmpDir
-
--- a/test/Utils.hs
+++ b/test/Utils.hs
@@ -11,16 +11,34 @@ import Control.Applicative
  )
 import Control.Monad
  (
-    void
+    forM_
+  , void
+  )
+import Control.Monad.IfElse
+  (
+    whenM
+  )
+import qualified Data.ByteString as BS
+import Data.IORef
+  (
+    newIORef
+  , readIORef
+  , writeIORef
+  , IORef
  )
 import HPath.IO
 import HPath.IO.Errors
-import HPath.IO.Utils
+import Prelude hiding (appendFile, readFile, writeFile)
 import Data.Maybe
  (
    fromJust
  )
 import qualified HPath as P
+import System.IO.Unsafe
+  (
+    unsafePerformIO
+  )
+import qualified System.Posix.Directory.Traversals as DT
 import System.Posix.Env.ByteString
  (
    getEnv
@@ -29,6 +47,7 @@ import Data.ByteString
  (
    ByteString
  )
+import qualified Data.ByteString.Lazy as L
 import System.Posix.Files.ByteString
  (
    groupExecuteMode
@@ -47,8 +66,13 @@ import qualified "unix-bytestring" System.Posix.IO.ByteString as SPB



-tmpDir :: ByteString
-tmpDir = "test/HPath/IO/tmp/"
+baseTmpDir :: ByteString
+baseTmpDir = "test/HPath/IO/tmp/"
+
+
+tmpDir :: IORef ByteString
+{-# NOINLINE tmpDir #-}
+tmpDir = unsafePerformIO (newIORef baseTmpDir)



@@ -57,31 +81,63 @@ tmpDir = "test/HPath/IO/tmp/"
    -----------------


+setTmpDir :: ByteString -> IO ()
+{-# NOINLINE setTmpDir #-}
+setTmpDir bs = writeIORef tmpDir (baseTmpDir `BS.append` bs)
+
+
 createTmpDir :: IO ()
+{-# NOINLINE createTmpDir #-}
 createTmpDir = do
  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
-  void $ createDir (pwd P.</> tmp)
+  tmp <- P.parseRel =<< readIORef tmpDir
+  void $ createDir newDirPerms (pwd P.</> tmp)


 deleteTmpDir :: IO ()
+{-# NOINLINE deleteTmpDir #-}
 deleteTmpDir = do
  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
+  tmp <- P.parseRel  =<< readIORef tmpDir
+  void $ deleteDir (pwd P.</> tmp)
+
+
+createBaseTmpDir :: IO ()
+{-# NOINLINE createBaseTmpDir #-}
+createBaseTmpDir = do
+  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
+  tmp <- P.parseRel baseTmpDir
+  void $ createDir newDirPerms (pwd P.</> tmp)
+
+
+deleteBaseTmpDir :: IO ()
+{-# NOINLINE deleteBaseTmpDir #-}
+deleteBaseTmpDir = do
+  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
+  tmp <- P.parseRel baseTmpDir
+  contents <- getDirsFiles (pwd P.</> tmp)
+  forM_ contents deleteDir
  void $ deleteDir (pwd P.</> tmp)


 withRawTmpDir :: (P.Path P.Abs -> IO a) -> IO a
+{-# NOINLINE withRawTmpDir #-}
 withRawTmpDir f = do
  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
+  tmp <- P.parseRel =<< readIORef tmpDir
  f (pwd P.</> tmp)


+getRawTmpDir :: IO ByteString
+{-# NOINLINE getRawTmpDir #-}
+getRawTmpDir = withRawTmpDir (return . flip BS.append "/" . P.fromAbs)
+
+
 withTmpDir :: ByteString -> (P.Path P.Abs -> IO a) -> IO a
+{-# NOINLINE withTmpDir #-}
 withTmpDir ip f = do
  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
+  tmp <- P.parseRel =<< readIORef tmpDir
  p <- (pwd P.</> tmp P.</>) <$> P.parseRel ip
  f p

@@ -90,84 +146,83 @@ withTmpDir' :: ByteString
            -> ByteString
            -> (P.Path P.Abs -> P.Path P.Abs -> IO a)
            -> IO a
+{-# NOINLINE withTmpDir' #-}
 withTmpDir' ip1 ip2 f = do
  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
+  tmp <- P.parseRel =<< readIORef tmpDir
  p1 <- (pwd P.</> tmp P.</>) <$> P.parseRel ip1
  p2 <- (pwd P.</> tmp P.</>) <$> P.parseRel ip2
  f p1 p2


 removeFileIfExists :: ByteString -> IO ()
+{-# NOINLINE removeFileIfExists #-}
 removeFileIfExists bs =
  withTmpDir bs $ \p -> whenM (doesFileExist p) (deleteFile p)


 removeDirIfExists :: ByteString -> IO ()
+{-# NOINLINE removeDirIfExists #-}
 removeDirIfExists bs =
  withTmpDir bs $ \p -> whenM (doesDirectoryExist p) (deleteDirRecursive p)


-copyFile' :: ByteString -> ByteString -> IO ()
-copyFile' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP copyFile
+copyFile' :: ByteString -> ByteString -> CopyMode -> IO ()
+{-# NOINLINE copyFile' #-}
+copyFile' inputFileP outputFileP cm =
+  withTmpDir' inputFileP outputFileP (\p1 p2 -> copyFile p1 p2 cm)


-copyFileOverwrite' :: ByteString -> ByteString -> IO ()
-copyFileOverwrite' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP copyFileOverwrite
-
-
-copyDirRecursive' :: ByteString -> ByteString -> IO ()
-copyDirRecursive' inputDirP outputDirP =
-  withTmpDir' inputDirP outputDirP copyDirRecursive
-
-
-copyDirRecursiveOverwrite' :: ByteString -> ByteString -> IO ()
-copyDirRecursiveOverwrite' inputDirP outputDirP =
-  withTmpDir' inputDirP outputDirP copyDirRecursiveOverwrite
+copyDirRecursive' :: ByteString -> ByteString
+                  -> CopyMode -> RecursiveErrorMode -> IO ()
+{-# NOINLINE copyDirRecursive' #-}
+copyDirRecursive' inputDirP outputDirP cm rm =
+  withTmpDir' inputDirP outputDirP (\p1 p2 -> copyDirRecursive p1 p2 cm rm)


 createDir' :: ByteString -> IO ()
-createDir' dest = withTmpDir dest createDir
+{-# NOINLINE createDir' #-}
+createDir' dest = withTmpDir dest (createDir newDirPerms)

+createDirRecursive' :: ByteString -> IO ()
+{-# NOINLINE createDirRecursive' #-}
+createDirRecursive' dest = withTmpDir dest (createDirRecursive newDirPerms)

 createRegularFile' :: ByteString -> IO ()
-createRegularFile' dest = withTmpDir dest createRegularFile
+{-# NOINLINE createRegularFile' #-}
+createRegularFile' dest = withTmpDir dest (createRegularFile newFilePerms)


 createSymlink' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE createSymlink' #-}
 createSymlink' dest sympoint = withTmpDir dest
  (\x -> createSymlink x sympoint)


 renameFile' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE renameFile' #-}
 renameFile' inputFileP outputFileP =
  withTmpDir' inputFileP outputFileP $ \i o -> do
    renameFile i o
    renameFile o i


-moveFile' :: ByteString -> ByteString -> IO ()
-moveFile' inputFileP outputFileP =
+moveFile' :: ByteString -> ByteString -> CopyMode -> IO ()
+{-# NOINLINE moveFile' #-}
+moveFile' inputFileP outputFileP cm =
  withTmpDir' inputFileP outputFileP $ \i o -> do
-    moveFile i o
-    moveFile o i
+    moveFile i o cm
+    moveFile o i Strict


-moveFileOverwrite' :: ByteString -> ByteString -> IO ()
-moveFileOverwrite' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP $ \i o -> do
-    moveFileOverwrite i o
-    moveFile o i
-
-
-recreateSymlink' :: ByteString -> ByteString -> IO ()
-recreateSymlink' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP recreateSymlink
+recreateSymlink' :: ByteString -> ByteString -> CopyMode -> IO ()
+{-# NOINLINE recreateSymlink' #-}
+recreateSymlink' inputFileP outputFileP cm =
+  withTmpDir' inputFileP outputFileP (\p1 p2 -> recreateSymlink p1 p2 cm)


 noWritableDirPerms :: ByteString -> IO ()
+{-# NOINLINE noWritableDirPerms #-}
 noWritableDirPerms path = withTmpDir path $ \p ->
  setFileMode (P.fromAbs p) perms
  where
@@ -180,42 +235,76 @@ noWritableDirPerms path = withTmpDir path $ \p ->


 noPerms :: ByteString -> IO ()
+{-# NOINLINE noPerms #-}
 noPerms path = withTmpDir path $ \p -> setFileMode (P.fromAbs p) nullFileMode


 normalDirPerms :: ByteString -> IO ()
+{-# NOINLINE normalDirPerms #-}
 normalDirPerms path =
  withTmpDir path $ \p -> setFileMode (P.fromAbs p) newDirPerms


+normalFilePerms :: ByteString -> IO ()
+{-# NOINLINE normalFilePerms #-}
+normalFilePerms path =
+  withTmpDir path $ \p -> setFileMode (P.fromAbs p) newFilePerms
+
+
 getFileType' :: ByteString -> IO FileType
+{-# NOINLINE getFileType' #-}
 getFileType' path = withTmpDir path getFileType


 getDirsFiles' :: ByteString -> IO [P.Path P.Abs]
+{-# NOINLINE getDirsFiles' #-}
 getDirsFiles' path = withTmpDir path getDirsFiles


 deleteFile' :: ByteString -> IO ()
+{-# NOINLINE deleteFile' #-}
 deleteFile' p = withTmpDir p deleteFile


 deleteDir' :: ByteString -> IO ()
+{-# NOINLINE deleteDir' #-}
 deleteDir' p = withTmpDir p deleteDir


 deleteDirRecursive' :: ByteString -> IO ()
+{-# NOINLINE deleteDirRecursive' #-}
 deleteDirRecursive' p = withTmpDir p deleteDirRecursive


 canonicalizePath' :: ByteString -> IO (P.Path P.Abs)
+{-# NOINLINE canonicalizePath' #-}
 canonicalizePath' p = withTmpDir p canonicalizePath


 writeFile' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE writeFile' #-}
 writeFile' ip bs = 
-  withTmpDir ip $ \p -> do
-    fd <- SPI.openFd (P.fromAbs p) SPI.WriteOnly Nothing
-                                   SPI.defaultFileFlags
-    SPB.fdWrite fd bs
-    SPI.closeFd fd
+  withTmpDir ip $ \p -> writeFile p bs
+
+
+appendFile' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE appendFile' #-}
+appendFile' ip bs =
+  withTmpDir ip $ \p -> appendFile p bs
+
+
+allDirectoryContents' :: ByteString -> IO [ByteString]
+{-# NOINLINE allDirectoryContents' #-}
+allDirectoryContents' ip =
+  withTmpDir ip $ \p -> DT.allDirectoryContents' (P.fromAbs p)
+
+
+readFile' :: ByteString -> IO ByteString
+{-# NOINLINE readFile' #-}
+readFile' p = withTmpDir p readFile
+
+
+readFileEOF' :: ByteString -> IO L.ByteString
+{-# NOINLINE readFileEOF' #-}
+readFileEOF' p = withTmpDir p readFileEOF
+
Author	SHA1	Message	Date
Julian Ospald	1c95c9f8f9	Bump to 0.8.1	2018-04-06 17:22:57 +02:00
Julian Ospald	0ec2cf8ca5	Add writeFile and appendFile	2018-04-06 17:22:38 +02:00
Julian Ospald	9ac10a6a7d	Add file reading functions	2018-04-06 16:42:40 +02:00
Julian Ospald	1a2c77c6a6	dirname: remove incorrect documentation on properties Fixes #11	2017-01-14 20:16:25 +01:00
Julian Ospald	3baecb7b51	Improve CopyDirRecursiveCollectFailures tests	2016-06-14 19:32:33 +02:00
Julian Ospald	5d5b0ae3c1	Add missing language pragma	2016-06-14 19:32:14 +02:00
Julian Ospald	f47c8edb42	Fix build for GHC < 7.10	2016-06-14 19:21:03 +02:00
Julian Ospald	ef66a24f87	Improve error handling * remove some obsolete functions and error types from HPath.IO.Errors that are completely unused * reworked the RecursiveFailure type to contain more information, so we can use it to programmatically make useful choices without examining the weakly types IO error attributes (like 'ioGetFileName')	2016-06-14 19:13:25 +02:00
Julian Ospald	f6a5cb8668	Add test to basename	2016-06-13 13:51:53 +02:00
Julian Ospald	4dec385332	Improve createDirRecursive	2016-06-13 01:38:44 +02:00
Julian Ospald	5b08e14b55	Add createDirRecursive, fixes #6	2016-06-13 01:28:55 +02:00
Julian Ospald	ac381cbf60	Improve documentation	2016-06-05 22:19:30 +02:00
Julian Ospald	ce7fdcdcd6	Move documentation note about RecursiveFailure where it belongs	2016-06-05 22:04:16 +02:00
Julian Ospald	a31c9d1e88	Improve documentation and tests for file creation	2016-06-05 21:59:31 +02:00
Julian Ospald	a5942ff026	Use IfElse package for whenM/unlessM	2016-06-05 21:52:52 +02:00
Julian Ospald	4d71ad08ce	Release 0.8.0	2016-06-05 17:56:31 +02:00
Julian Ospald	92017ab630	Make createRegularFile and createDir accept FileMode parameter	2016-06-05 17:46:25 +02:00
Julian Ospald	16af98b32d	Be more specific about Overwrite mode	2016-06-05 16:38:54 +02:00
Julian Ospald	6da01e382f	Improve documentation	2016-06-05 16:31:08 +02:00
Julian Ospald	ed06543981	Proper GHC conditionals to fix compiler warnings	2016-06-05 16:16:41 +02:00
Julian Ospald	d3eb2fc254	Fix build with GHC-7.8	2016-06-05 16:12:51 +02:00
Julian Ospald	a1eb06324f	Rm unused imports	2016-06-05 16:09:34 +02:00
Julian Ospald	d12ce30f57	Fix docs and rename RecursiveMode to RecursiveErrorMode	2016-06-05 16:07:46 +02:00
Julian Ospald	7a6f0e8728	Fix spelling	2016-06-05 16:00:15 +02:00
Julian Ospald	7ed5829d47	Fix documentation	2016-06-05 15:57:41 +02:00
Julian Ospald	d708f80a1f	TESTS: don't assume ordering of exceptions	2016-06-05 15:37:26 +02:00
Julian Ospald	f07619b7c6	TESTS: fix before/after	2016-06-05 15:25:57 +02:00
Julian Ospald	c5bcb90b65	TESTS: don't use lazy IO -.-	2016-06-05 14:55:21 +02:00
Julian Ospald	4f047dbc77	TESTS: import unsafePerformIO from System.IO.Unsafe	2016-06-05 14:46:45 +02:00
Julian Ospald	bc348c7dd5	TESTS: less side effects plz	2016-06-05 14:33:53 +02:00
Julian Ospald	5d1c5cc2ce	Fix linter warning	2016-06-05 03:26:05 +02:00
Julian Ospald	8f6ca81d22	Add tests to RecreateSymlinkOverwriteSpec	2016-06-05 03:22:35 +02:00
Julian Ospald	a27d4ed55d	Improve documentation	2016-06-05 03:22:11 +02:00
Julian Ospald	64ae6db83a	New API: use CopyMode for overwriting and introduce RecursiveMode This allows to specify the behavior on recursive operations, such that one can collect failures instead of dying on the first failure.	2016-06-05 03:13:33 +02:00
Julian Ospald	2a0a88a96d	Release 0.7.5	2016-06-04 00:39:03 +02:00
Julian Ospald	69dbf6714d	Relicense to BSD3	2016-06-04 00:39:03 +02:00