Release 0.8.0

This allows to specify the behavior on recursive operations,
such that one can collect failures instead of dying on the first
failure.

.travis.yml

@@ -0,0 +1,61 @@
+# See https://github.com/hvr/multi-ghc-travis for more information
+
+language: c
+
+sudo: required
+dist: trusty
+
+matrix:
+  include:
+    - env: CABALVER=1.22 GHCVER=7.8.4
+      addons: {apt: {packages: [cabal-install-1.22,ghc-7.8.4], sources: [hvr-ghc]}}
+    - env: CABALVER=1.24 GHCVER=7.10.2
+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.10.2], sources: [hvr-ghc]}}
+    - env: CABALVER=1.24 GHCVER=8.0.1
+      addons: {apt: {packages: [cabal-install-1.24,ghc-8.0.1], sources: [hvr-ghc]}}
+    - env: CABALVER=head GHCVER=head
+      addons: {apt: {packages: [cabal-install-head,ghc-head],  sources: [hvr-ghc]}}
+
+  allow_failures:
+    - env: CABALVER=head GHCVER=head
+
+env:
+  global:
+    - secure: q++z4DGwOHYjmed00oxMnGhBTzOBzKYunXvVcnCEmvmzW3qZERtXj3B7CLW4vRtmBlo3SiM0fb25NeYao+ByzTjo8jk9noiBVZvffwRmlKCeVwYx7T4/rsDhfV97k2JOeahBSgxWNuTkt+5gv07HpKdTiIxJsiv/QdBxQeq6/Ly6dyRskmCt+VuFvQg+cqPMugxIXtY6F7eZ1zgl/LxlamWjO3E4lX0Myf4o8+SU1HRDVkkVe+ytnRcVcYI2FHuFV/sSoDMTweXQToA9roVjOkfhq4rGlPCuXJkBPyZW2otLXgAV7I2kjwgxqmS5Yw752CcFjMMbG6R1u8sEAcGrJNKHfx8sKqBwI0AVoq4CJn+nKSElTDl0KI1mqazmazK4/mddkD9NGIVXCFmw4b+YGf1uDj8FAR94UmOiEFkEObGkQxG1XK/uzDaUJ1tO3MYXjPPEIE89BJORo+ZskmKFEoqbrBR/vEjbXxJHWP7SaaoM+mWpMiSssEFb/Z5mDBFPb2P/2f7nO4ZDfOYp/9hZdBvDaVM8FmTQfzF6jIUIOFmeeiSZWIBAHoDfdZDRrM/hC5JzqfMumW9frwllsQtYytkAsUqlNnCW86jlc5/5L6D8eY2NERFI2DRqrBi7bP2AfYXsozY0gMO1RL5+iQSQVKlPhk6IyAJYCWCYnrA+dz4=
+
+before_install:
+ - sudo apt-get install -y hscolour
+ - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+
+install:
+ - cabal --version
+ - travis_retry cabal update
+ - cabal sandbox init
+ - cabal install --only-dependencies --enable-tests -j
+
+script:
+ - cabal configure --enable-tests -v2
+ - cabal build
+ - cabal test
+ - cabal check
+ - cabal sdist
+ - cabal haddock --hyperlink-source --html-location=https://hackage.haskell.org/package/\$pkg-\$version/docs/
+# check that the generated source-distribution can be built & installed
+ - export SRC_TGZ=$(cabal info . | awk '{print $2 ".tar.gz";exit}') ;
+   cd dist/;
+   cabal sandbox init;
+   if [ -f "$SRC_TGZ" ]; then
+      cabal install "$SRC_TGZ" --enable-tests;
+   else
+      echo "expected '$SRC_TGZ' not found";
+      exit 1;
+   fi;
+   cd ..
+
+after_script:
+    - ./update-gh-pages.sh
+
+notifications:
+  email:
+    - hasufell@posteo.de
+

CHANGELOG

@@ -1,3 +1,35 @@
+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:
+	* fix tests, so they work with the sdist tarball too
+	* added the following function to HPath.IO: createSymlink
+0.7.1:
+	* various cleanups and documentation improvements
+	* added the following functions to System.Posix.FilePath: splitSearchPath, getSearchPath, stripExtension, makeRelative, makeValid
+0.7.0:
+	* use 'sendfile' from 'simple-sendfile' in _copyFile and do read/write as a fallback only
+	* add isFileName, hasParentDir, hiddenFile to System.Posix.FilePath
+	* add our own openFd version for more control
+	* small documentation improvements
+	* add a getDirectoryContents' version that works on Fd
+	* lift version constraints in benchmark
+	* remove fpToString and userStringToFP, use Data.ByteString.UTF8 directly instead
+0.6.0:
+	* fixes 'throwDestinationInSource' to be more reliable.
+	* removes some unused HPathIOException constructors
+	* consistently provide exception constructor identifiers
+	* be less harsh when non-supported file types get passed to our functions, possibly ignoring them
+	* minor cleanups
+0.5.9:
+	* Adds our posix-paths fork and a lot of IO operations.
 0.5.8:
 	* First version of the fork.
 0.5.7:

LICENSE

@@ -1,25 +1,30 @@
-Copyright (c) 2015–2016, FP Complete
-Copyright (c) 2016, Julian Ospald
+Copyright (c) Julian Ospald
+
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
+
+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.
-    * Neither the name of paths nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+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 <COPYRIGHT HOLDER> 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.
+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.

README.md

@@ -1,6 +1,9 @@
 # HPath
 
-Support for well-typed paths in Haskell.
+[![Gitter chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/hasufell/hpath?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Hackage version](https://img.shields.io/hackage/v/hpath.svg?label=Hackage)](https://hackage.haskell.org/package/hpath) [![Build Status](https://api.travis-ci.org/hasufell/hpath.png?branch=master)](http://travis-ci.org/hasufell/hpath)
+
+Support for well-typed paths in Haskell. Also provides ByteString based filepath
+manipulation.
 
 ## Motivation
 
@@ -14,67 +17,71 @@ The library that came closest to my needs was
 but the API turned out to be oddly complicated for my use case, so I
 decided to fork it.
 
+Similarly, [posix-paths](https://github.com/JohnLato/posix-paths)
+was exactly what I wanted for the low-level operations, but upstream seems dead,
+so it is forked as well and merged into this library.
+
+## Goals
+
+* well-typed paths
+* high-level API to file operations like recursive directory copy
+* safe filepath manipulation, never using String as filepath, but ByteString
+* still allowing sufficient control to interact with the underlying low-level calls
+
+Note: this library was written for __posix__ systems and it will probably not support other systems.
+
 ## Differences to 'path'
 
-I wasn't happy with the way it dealt with Dir vs File things. In his
-version of the library, a `Path b Dir` always ends with a trailing
-path separator and `Path b File` never ends with a trailing path separator.
+* doesn't attempt to fake IO-related information into the path, so whether a path points to a file or directory is up to your IO-code to decide...
+* trailing path separators will be preserved if they exist, no messing with that
+* uses safe ByteString for filepaths under the hood instead of unsafe String
+* fixes broken [dirname](https://github.com/chrisdone/path/issues/18)
+* renames dirname/filename to basename/dirname to match the POSIX shell functions
+* introduces a new `Path Fn` for safe filename guarantees and a `RelC` class
+* allows pattern matching via unidirectional PatternSynonym
+* uses simple doctest for testing
+* allows `~/` as relative path, because on posix level `~` is just a regular filename that does _NOT_ point to `$HOME`
+* remove TH, it sucks
 
-IMO, it is nonsensical to make a Dir vs File distinction on path level,
-although it first seems nice.
-Some of the reasons are:
-* a path is just that: a path. It is completely disconnected from IO level
-  and even if a `Dir`/`File` type theoretically allows us to say "this path
-  ought to point to a file", there is literally zero guarantee that it will
-  hold true at runtime. So this basically gives a false feeling of a
-  type-safe file distinction.
-* it's imprecise about Dir vs File distinction, which makes it even worse,
-  because a directory is also a file (just not a regular file). Add symlinks
-  to that and the confusion is complete.
-* it makes the API oddly complicated for use cases where we basically don't
-  care (yet) whether something turns out to be a directory or not
+## Differences to 'posix-paths'
 
-Still, it comes also with a few perks:
-* it simplifies some functions, because they now have guarantees whether a
-  path ends in a trailing path separator or not
-* it may be safer for interaction with other library functions, which behave
-  differently depending on a trailing path separator (like probably shelly)
+* uses the `word8` package for save word8 literals instead of `OverloadedStrings`
+* `hasTrailingPathSeparator` and `dropTrailingPathSeparator` behave in the same way as their `System.FilePath` counterpart
+* added various functions:
+    * `equalFilePath`
+    * `getSearchPath`
+    * `hasParentDir`
+    * `hiddenFile`
+    * `isFileName`
+    * `isValid`
+    * `makeRelative`
+    * `makeValid`
+    * `normalise`
+    * `splitSearchPath`
+    * `stripExtension`
+* has a custom versions of `openFd` which allows more control over the flags than its unix package counterpart
+* adds a `getDirectoryContents'` version that works on Fd
 
-Not limited to, but also in order to fix my remarks without breaking any
-benefits, I did:
-* rename the `Dir`/`File` types to `TPS`/`NoTPS`, so it's clear we are only
-  giving information about trailing path separators and not actual file
-  types we don't know about yet
-* add a `MaybeTPS` type, which does not mess with trailing path separators
-  and also gives no guarantees about them... then added `toNoTPS` and
-  `toTPS` to allow type-safe conversion
-* make some functions accept more general types, so we don't unnecessarily
-  force paths with trailing separators for `(</>)` for example... instead
-  these functions now examine the paths to still have correct behavior.
-  This is really minor overhead. You might say now "but then I can append
-  filepath to filepath". Well, as I said... we don't know whether it's a
-  "filepath" at all.
-* merge `filename` and `dirname` into `basename` and make `parent` be
-  `dirname`, so the function names match the name of the POSIX ones,
-  which do (almost) the same...
-* fix a bug in `basename` (formerly `dirname`) which broke the type
-  guarantees
-* add a pattern synonym for easier pattern matching without exporting
-  the internal Path constructor
+## Examples in ghci
 
-## Consequences
+Start ghci via `cabal repl`:
 
-So what does that mean? Well, it means that this library does not and
-cannot make any guarantees about what a filepath is meant for or what
-it might point to. And it doesn't pretend it can.
-
-So when you strip the trailing path separator of a path that points to a
-directory  and then shove it into some function which expects a regular
-file... then that function will very likely blow up. That's the nature of IO.
-There is no type that can save you from interfacing such low-level libraries.
-The filesystem is in constant change. What might have been a regular file
-2 seconds ago, can now be a directory or a symlink.
-That means you need a proper File type that is tied to your IO code.
-This is what [hsfm](https://github.com/hasufell/hsfm) does. It currently
-is not a library, maybe it will be in the future.
+```hs
+-- enable OverloadedStrings
+:set -XOverloadedStrings
+-- import HPath.IO
+import HPath.IO
+-- parse an absolute path
+abspath <- parseAbs "/home"
+-- parse a relative path (e.g. user users home directory)
+relpath <- parseRel "jule"
+-- concatenate paths
+let newpath = abspath </> relpath
+-- get file type
+getFileType newpath
+-- return all contents of that directory
+getDirsFiles newpath
+-- return all contents of the parent directory
+getDirsFiles (dirname newpath)
+```
 

cbits/dirutils.c

@@ -0,0 +1,7 @@
+#include "dirutils.h"
+unsigned int
+    __posixdir_d_type(struct dirent* d)
+    {
+      return(d -> d_type);
+    }
+

cbits/dirutils.h

@@ -0,0 +1,13 @@
+#ifndef POSIXPATHS_CBITS_DIRUTILS_H
+#define POSIXPATHS_CBITS_DIRUTILS_H
+
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+extern unsigned int
+    __posixdir_d_type(struct dirent* d)
+    ;
+#endif

doctests-hpath.hs

@@ -0,0 +1,13 @@
+module Main where
+
+
+import Test.DocTest
+import Test.HUnit
+
+main =
+    doctest
+      ["-isrc"
+      , "-XOverloadedStrings"
+      , "src/HPath.hs"
+      ]
+

doctests-posix.hs

@@ -0,0 +1,25 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module Main where
+
+import Control.Applicative
+import System.Posix.Directory.Traversals
+
+import Test.DocTest
+import Test.HUnit
+
+main = do
+    doctest
+      [ "-isrc"
+      , "-XOverloadedStrings"
+      , "System.Posix.FilePath"
+      ]
+    runTestTT unitTests
+
+
+unitTests :: Test
+unitTests = test
+    [ TestCase $ do
+        r <- (==) <$> allDirectoryContents "." <*> allDirectoryContents' "."
+        assertBool "allDirectoryContents == allDirectoryContents'" r
+    ]

hpath.cabal

@@ -1,37 +1,113 @@
 name:                hpath
-version:             0.5.8
+version:             0.8.0
 synopsis:            Support for well-typed paths
-description:         Support for will-typed paths.
+description:         Support for well-typed paths, utilizing ByteString under the hood.
 license:             BSD3
 license-file:        LICENSE
 author:              Julian Ospald <hasufell@posteo.de>
 maintainer:          Julian Ospald <hasufell@posteo.de>
-copyright:           2015–2016 FP Complete, Julian Ospald 2016
+copyright:           Julian Ospald 2016
 category:            Filesystem
 build-type:          Simple
-cabal-version:       >=1.8
-extra-source-files:  README.md, CHANGELOG
+cabal-version:       >=1.14
+extra-source-files:  README.md
+                     CHANGELOG
+                     cbits/dirutils.h
+                     doctests-hpath.hs
+                     doctests-posix.hs
 
 library
   hs-source-dirs:    src/
-  ghc-options:       -Wall -O2
-  exposed-modules:   HPath, HPath.Internal
-  build-depends:     base >= 4 && <5
-                   , exceptions
-                   , filepath
-                   , template-haskell
+  default-language:  Haskell2010
+  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
+                   , bytestring >= 0.9.2.0
                    , deepseq
-
-test-suite test
-    type: exitcode-stdio-1.0
-    main-is: Main.hs
-    hs-source-dirs: test
-    build-depends: HUnit
-                 , base
+                   , exceptions
                    , hspec
-                 , mtl
+                   , simple-sendfile >= 0.2.24
+                   , unix >= 2.5
+                   , unix-bytestring
+                   , utf8-string
+                   , word8
+
+
+test-suite doctests-hpath
+  default-language:  Haskell2010
+  type:              exitcode-stdio-1.0
+  ghc-options:       -threaded
+  main-is:           doctests-hpath.hs
+  build-depends:     base
+                   , HUnit
+                   , QuickCheck
+                   , doctest >= 0.8
                    , hpath
 
+test-suite doctests-posix
+  default-language:  Haskell2010
+  type:              exitcode-stdio-1.0
+  ghc-options:       -threaded
+  main-is:           doctests-posix.hs
+  build-depends:     base,
+                     bytestring,
+                     unix,
+                     hpath,
+                     doctest >= 0.8,
+                     HUnit,
+                     QuickCheck
+
+test-suite spec
+  Type:                 exitcode-stdio-1.0
+  Default-Language:     Haskell2010
+  Hs-Source-Dirs:       test
+  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.CreateRegularFileSpec
+                        HPath.IO.CreateSymlinkSpec
+                        HPath.IO.DeleteDirRecursiveSpec
+                        HPath.IO.DeleteDirSpec
+                        HPath.IO.DeleteFileSpec
+                        HPath.IO.GetDirsFilesSpec
+                        HPath.IO.GetFileTypeSpec
+                        HPath.IO.MoveFileOverwriteSpec
+                        HPath.IO.MoveFileSpec
+                        HPath.IO.RecreateSymlinkOverwriteSpec
+                        HPath.IO.RecreateSymlinkSpec
+                        HPath.IO.RenameFileSpec
+                        Spec
+                        Utils
+  GHC-Options:          -Wall
+  Build-Depends:        base
+                      , HUnit
+                      , bytestring
+                      , hpath
+                      , hspec >= 1.3
+                      , process
+                      , unix
+                      , unix-bytestring
+                      , utf8-string
+
 source-repository head
   type:     git
   location: https://github.com/hasufell/hpath
+

src/HPath.hs

@@ -9,64 +9,61 @@
 --
 -- Support for well-typed paths.
 
-{-# LANGUAGE TemplateHaskell #-}
+
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE EmptyDataDecls #-}
 {-# LANGUAGE PatternSynonyms #-}
-{-# OPTIONS_HADDOCK ignore-exports #-}
 
 module HPath
   (
   -- * Types
    Abs
-  ,NoTPS
   ,Path
   ,Rel
-  ,TPS
+  ,Fn
+  ,PathParseException
+  ,PathException
+  ,RelC
   -- * PatternSynonyms/ViewPatterns
   ,pattern Path
-   -- * Parsing
-  ,PathParseException
-  ,parseAbsMaybeTPS
-  ,parseAbsNoTPS
-  ,parseAbsTPS
-  ,parseRelMaybeTPS
-  ,parseRelNoTPS
-  ,parseRelTPS
-  -- * Constructors
-  ,mkAbsMaybeTPS
-  ,mkAbsNoTPS
-  ,mkAbsTPS
-  ,mkRelMaybeTPS
-  ,mkRelNoTPS
-  ,mkRelTPS
-  -- * Operations
+   -- * Path Parsing
+  ,parseAbs
+  ,parseFn
+  ,parseRel
+  -- * Path Conversion
+  ,fromAbs
+  ,fromRel
+  ,toFilePath
+  -- * Path Operations
   ,(</>)
   ,basename
   ,dirname
   ,isParentOf
+  ,getAllParents
   ,stripDir
-  -- * Conversion
-  ,fromAbsMaybeTPS
-  ,fromAbsNoTPS
-  ,fromAbsTPS
-  ,fromRelMaybeTPS
-  ,fromRelNoTPS
-  ,fromRelTPS
-  ,toFilePath
-  ,toNoTPS
-  ,toTPS
+  -- * Path IO helpers
+  ,withAbsPath
+  ,withRelPath
+  ,withFnPath
   )
   where
 
 import           Control.Exception (Exception)
 import           Control.Monad.Catch (MonadThrow(..))
+#if MIN_VERSION_bytestring(0,10,8)
+import           Data.ByteString(ByteString, stripPrefix)
+#else
+import           Data.ByteString(ByteString)
+import qualified Data.List as L
+#endif
+import qualified Data.ByteString as BS
 import           Data.Data
-import           Data.List
 import           Data.Maybe
-import           Language.Haskell.TH
+import           Data.Word8
 import           HPath.Internal
-import qualified System.FilePath as FilePath
+import           System.Posix.FilePath hiding ((</>))
+
 
 --------------------------------------------------------------------------------
 -- Types
@@ -77,259 +74,162 @@ data Abs deriving (Typeable)
 -- | A relative path; one without a root.
 data Rel deriving (Typeable)
 
--- | A path without trailing separator.
-data NoTPS deriving (Typeable)
-
--- | A path with trailing separator.
-data TPS deriving (Typeable)
-
--- | A path without any guarantee about whether it ends in a
--- trailing path separators. Use `toTPS` and `toNoTPS`
--- if that guarantee is required.
-data MaybeTPS deriving (Typeable)
+-- | A filename, without any '/'.
+data Fn deriving (Typeable)
 
 -- | Exception when parsing a location.
 data PathParseException
-  = InvalidAbsTPS FilePath
-  | InvalidRelTPS FilePath
-  | InvalidAbsNoTPS FilePath
-  | InvalidRelNoTPS FilePath
-  | InvalidAbsMaybeTPS FilePath
-  | InvalidRelMaybeTPS FilePath
-  | Couldn'tStripPrefixTPS FilePath FilePath
+  = InvalidAbs ByteString
+  | InvalidRel ByteString
+  | InvalidFn ByteString
+  | Couldn'tStripPrefixTPS ByteString ByteString
   deriving (Show,Typeable)
 instance Exception PathParseException
 
+data PathException = RootDirHasNoBasename
+  deriving (Show,Typeable)
+instance Exception PathException
+
+class RelC m
+
+instance RelC Rel
+instance RelC Fn
+
 --------------------------------------------------------------------------------
 -- PatternSynonyms
 
+#if __GLASGOW_HASKELL__ >= 710
+pattern Path :: ByteString -> Path a
+#endif
 pattern Path x <- (MkPath x)
 
 --------------------------------------------------------------------------------
--- Parsers
+-- Path Parsers
 
--- | Get a location for an absolute path. Produces a normalized
---  path which always ends in a path separator.
+
+
+-- | Get a location for an absolute path. Produces a normalised path.
 --
 -- Throws: 'PathParseException'
 --
-parseAbsTPS :: MonadThrow m
-            => FilePath -> m (Path Abs TPS)
-parseAbsTPS filepath =
-  if FilePath.isAbsolute filepath &&
-     not (null (normalizeTPS filepath)) &&
-     not ("~/" `isPrefixOf` filepath) &&
-     not (hasParentDir filepath) &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeTPS filepath))
-     else throwM (InvalidAbsTPS filepath)
+-- >>> parseAbs "/abc"          :: Maybe (Path Abs)
+-- Just "/abc"
+-- >>> parseAbs "/"             :: Maybe (Path Abs)
+-- Just "/"
+-- >>> parseAbs "/abc/def"      :: Maybe (Path Abs)
+-- Just "/abc/def"
+-- >>> parseAbs "/abc/def/.///" :: Maybe (Path Abs)
+-- Just "/abc/def/"
+-- >>> parseAbs "abc"           :: Maybe (Path Abs)
+-- Nothing
+-- >>> parseAbs ""              :: Maybe (Path Abs)
+-- Nothing
+-- >>> parseAbs "/abc/../foo"   :: Maybe (Path Abs)
+-- Nothing
+parseAbs :: MonadThrow m
+         => ByteString -> m (Path Abs)
+parseAbs filepath =
+  if isAbsolute filepath &&
+     isValid filepath &&
+     not (hasParentDir filepath)
+     then return (MkPath $ normalise filepath)
+     else throwM (InvalidAbs filepath)
 
--- | Get a location for a relative path. Produces a normalized
--- path which always ends in a path separator.
+
+-- | Get a location for a relative path. Produces a normalised
+-- path.
 --
 -- Note that @filepath@ may contain any number of @./@ but may not consist
 -- solely of @./@.  It also may not contain a single @..@ anywhere.
 --
 -- Throws: 'PathParseException'
 --
-parseRelTPS :: MonadThrow m
-            => FilePath -> m (Path Rel TPS)
-parseRelTPS filepath =
-  if not (FilePath.isAbsolute filepath) &&
-     not (null filepath) &&
-     not ("~/" `isPrefixOf` filepath) &&
+-- >>> parseRel "abc"        :: Maybe (Path Rel)
+-- Just "abc"
+-- >>> parseRel "def/"       :: Maybe (Path Rel)
+-- Just "def/"
+-- >>> parseRel "abc/def"    :: Maybe (Path Rel)
+-- Just "abc/def"
+-- >>> parseRel "abc/def/."  :: Maybe (Path Rel)
+-- Just "abc/def/"
+-- >>> parseRel "/abc"       :: Maybe (Path Rel)
+-- Nothing
+-- >>> parseRel ""           :: Maybe (Path Rel)
+-- Nothing
+-- >>> parseRel "abc/../foo" :: Maybe (Path Rel)
+-- Nothing
+-- >>> parseRel "."          :: Maybe (Path Rel)
+-- Nothing
+-- >>> parseRel ".."         :: Maybe (Path Rel)
+-- Nothing
+parseRel :: MonadThrow m
+         => ByteString -> m (Path Rel)
+parseRel filepath =
+  if not (isAbsolute filepath) &&
+     filepath /= BS.singleton _period &&
+     filepath /= BS.pack [_period, _period] &&
      not (hasParentDir filepath) &&
-     not (null (normalizeTPS filepath)) &&
-     filepath /= "." && filepath /= ".." &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeTPS filepath))
-     else throwM (InvalidRelTPS filepath)
+     isValid filepath
+     then return (MkPath $ normalise filepath)
+     else throwM (InvalidRel filepath)
 
--- | Get a location for an absolute path, which must not end with a trailing
--- path separator.
+
+-- | Parses a filename. Filenames must not contain slashes.
+-- Excludes '.' and '..'.
 --
 -- Throws: 'PathParseException'
 --
-parseAbsNoTPS :: MonadThrow m
-              => FilePath -> m (Path Abs NoTPS)
-parseAbsNoTPS filepath =
-  if FilePath.isAbsolute filepath &&
-     not (FilePath.hasTrailingPathSeparator filepath) &&
-     not ("~/" `isPrefixOf` filepath) &&
-     not (hasParentDir filepath) &&
-     not (null (normalizeNoTPS filepath)) &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeNoTPS filepath))
-     else throwM (InvalidAbsNoTPS filepath)
+-- >>> parseFn "abc"        :: Maybe (Path Fn)
+-- Just "abc"
+-- >>> parseFn "..."        :: Maybe (Path Fn)
+-- Just "..."
+-- >>> parseFn "def/"       :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn "abc/def"    :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn "abc/def/."  :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn "/abc"       :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn ""           :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn "abc/../foo" :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn "."          :: Maybe (Path Fn)
+-- Nothing
+-- >>> parseFn ".."         :: Maybe (Path Fn)
+-- Nothing
+parseFn :: MonadThrow m
+        => ByteString -> m (Path Fn)
+parseFn filepath =
+  if isFileName filepath &&
+     filepath /= BS.singleton _period &&
+     filepath /= BS.pack [_period, _period] &&
+     isValid filepath
+     then return (MkPath filepath)
+     else throwM (InvalidFn filepath)
 
--- | Get a location for a relative path, which must not end with a trailing
--- path separator.
---
--- Note that @filepath@ may contain any number of @./@ but may not contain a
--- single @..@ anywhere.
---
--- Throws: 'PathParseException'
---
-parseRelNoTPS :: MonadThrow m
-              => FilePath -> m (Path Rel NoTPS)
-parseRelNoTPS filepath =
-  if not (FilePath.isAbsolute filepath ||
-          FilePath.hasTrailingPathSeparator filepath) &&
-     not (null filepath) &&
-     not ("~/" `isPrefixOf` filepath) &&
-     not (hasParentDir filepath) &&
-     not (null (normalizeNoTPS filepath)) &&
-     filepath /= "." && filepath /= ".." &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeNoTPS filepath))
-     else throwM (InvalidRelNoTPS filepath)
 
--- | Get a location for an absolute path that may or may not end in a trailing
--- path separator. Use `toTPS` and `toNoTPS` if that guarantee is required.
---
--- Throws: 'PathParseException'
---
-parseAbsMaybeTPS :: MonadThrow m
-                 => FilePath -> m (Path Abs MaybeTPS)
-parseAbsMaybeTPS filepath =
-  if FilePath.isAbsolute filepath &&
-     not ("~/" `isPrefixOf` filepath) &&
-     not (hasParentDir filepath) &&
-     not (null (normalizeNoTPS filepath)) &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeNoTPS filepath))
-     else throwM (InvalidAbsMaybeTPS filepath)
-
--- | Get a location for a relative path that may or may not end in a trailing
--- path separator. Use `toTPS` and `toNoTPS` if that guarantee is required.
---
--- Note that @filepath@ may contain any number of @./@ but may not contain a
--- single @..@ anywhere.
---
--- Throws: 'PathParseException'
---
-parseRelMaybeTPS :: MonadThrow m
-                 => FilePath -> m (Path Rel MaybeTPS)
-parseRelMaybeTPS filepath =
-  if not (FilePath.isAbsolute filepath) &&
-     not (null filepath) &&
-     not ("~/" `isPrefixOf` filepath) &&
-     not (hasParentDir filepath) &&
-     not (null (normalizeNoTPS filepath)) &&
-     filepath /= "." && filepath /= ".." &&
-     FilePath.isValid filepath
-     then return (MkPath (normalizeNoTPS filepath))
-     else throwM (InvalidRelMaybeTPS filepath)
-
--- | Helper function: check if the filepath has any parent directories in it.
--- This handles the logic of checking for different path separators on Windows.
-hasParentDir :: FilePath -> Bool
-hasParentDir filepath' =
-     ("/.." `isSuffixOf` filepath) ||
-     ("/../" `isInfixOf` filepath) ||
-     ("../" `isPrefixOf` filepath)
-  where
-    filepath =
-        case FilePath.pathSeparator of
-            '/' -> filepath'
-            x   -> map (\y -> if x == y then '/' else y) filepath'
 
 --------------------------------------------------------------------------------
--- Constructors
+-- Path Conversion
 
--- | Make a 'Path Abs TPS'.
---
--- Remember: due to the nature of absolute paths this (e.g. @\/home\/foo@)
--- may compile on your platform, but it may not compile on another
--- platform (Windows).
-mkAbsTPS :: FilePath -> Q Exp
-mkAbsTPS s =
-  case parseAbsTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Abs TPS|]
-
--- | Make a 'Path Rel TPS'.
-mkRelTPS :: FilePath -> Q Exp
-mkRelTPS s =
-  case parseRelTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Rel TPS|]
-
--- | Make a 'Path Abs NoTPS'.
---
--- Remember: due to the nature of absolute paths this (e.g. @\/home\/foo@)
--- may compile on your platform, but it may not compile on another
--- platform (Windows).
-mkAbsNoTPS :: FilePath -> Q Exp
-mkAbsNoTPS s =
-  case parseAbsNoTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Abs NoTPS|]
-
--- | Make a 'Path Rel NoTPS'.
-mkRelNoTPS :: FilePath -> Q Exp
-mkRelNoTPS s =
-  case parseRelNoTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Rel NoTPS|]
-
--- | Make a 'Path Rel MaybeTPS'.
-mkAbsMaybeTPS :: FilePath -> Q Exp
-mkAbsMaybeTPS s =
-  case parseAbsMaybeTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Abs MaybeTPS|]
-
--- | Make a 'Path Rel MaybeTPS'.
-mkRelMaybeTPS :: FilePath -> Q Exp
-mkRelMaybeTPS s =
-  case parseRelMaybeTPS s of
-    Left err -> error (show err)
-    Right (MkPath str) ->
-      [|MkPath $(return (LitE (StringL str))) :: Path Rel MaybeTPS|]
-
---------------------------------------------------------------------------------
--- Conversion
-
--- | Convert to a 'FilePath' type.
---
--- All TPS data types have a trailing slash, so if you want no trailing
--- slash, you can use 'System.FilePath.dropTrailingPathSeparator' from
--- the filepath package.
-toFilePath :: Path b t -> FilePath
+-- | Convert any Path to a ByteString type.
+toFilePath :: Path b -> ByteString
 toFilePath (MkPath l) = l
 
-fromAbsTPS :: Path Abs TPS -> FilePath
-fromAbsTPS = toFilePath
+-- | Convert an absolute Path to a ByteString type.
+fromAbs :: Path Abs -> ByteString
+fromAbs = toFilePath
 
-fromRelTPS :: Path Rel TPS -> FilePath
-fromRelTPS = toFilePath
+-- | Convert a relative Path to a ByteString type.
+fromRel :: RelC r => Path r -> ByteString
+fromRel = toFilePath
 
-fromAbsNoTPS :: Path Abs NoTPS -> FilePath
-fromAbsNoTPS = toFilePath
 
-fromRelNoTPS :: Path Rel NoTPS -> FilePath
-fromRelNoTPS = toFilePath
-
-fromAbsMaybeTPS :: Path Abs MaybeTPS -> FilePath
-fromAbsMaybeTPS = toFilePath
-
-fromRelMaybeTPS :: Path Rel MaybeTPS -> FilePath
-fromRelMaybeTPS = toFilePath
-
-toTPS :: Path b MaybeTPS -> Path b TPS
-toTPS (MkPath l) = MkPath (FilePath.addTrailingPathSeparator l)
-
-toNoTPS :: Path b MaybeTPS -> Path b NoTPS
-toNoTPS (MkPath l) = MkPath (FilePath.dropTrailingPathSeparator l)
 
 --------------------------------------------------------------------------------
--- Operations
+-- Path Operations
 
 -- | Append two paths.
 --
@@ -339,31 +239,78 @@ toNoTPS (MkPath l) = MkPath (FilePath.dropTrailingPathSeparator l)
 -- Technically, the first argument can be a path that points to a non-directory,
 -- because this library is IO-agnostic and makes no assumptions about
 -- file types.
-(</>) :: Path b t1 -> Path Rel t2 -> Path b t2
-(</>) (MkPath a) (MkPath b) = MkPath (a' ++ b)
+--
+-- >>> (MkPath "/")        </> (MkPath "file"     :: Path Rel)
+-- "/file"
+-- >>> (MkPath "/path/to") </> (MkPath "file"     :: Path Rel)
+-- "/path/to/file"
+-- >>> (MkPath "/")        </> (MkPath "file/lal" :: Path Rel)
+-- "/file/lal"
+-- >>> (MkPath "/")        </> (MkPath "file/"    :: Path Rel)
+-- "/file/"
+(</>) :: RelC r => Path b -> Path r -> Path b
+(</>) (MkPath a) (MkPath b) = MkPath (a' `BS.append` b)
   where
-    a' = FilePath.addTrailingPathSeparator a
+    a' = if BS.last a == pathSeparator
+         then a
+         else addTrailingPathSeparator a
 
 -- | Strip directory from path, making it relative to that directory.
 -- Throws 'Couldn'tStripPrefixDir' if directory is not a parent of the path.
 --
 -- The bases must match.
 --
+-- >>> (MkPath "/lal/lad")     `stripDir` (MkPath "/lal/lad/fad") :: Maybe (Path Rel)
+-- Just "fad"
+-- >>> (MkPath "lal/lad")      `stripDir` (MkPath "lal/lad/fad")  :: Maybe (Path Rel)
+-- Just "fad"
+-- >>> (MkPath "/")            `stripDir` (MkPath "/")            :: Maybe (Path Rel)
+-- Nothing
+-- >>> (MkPath "/lal/lad/fad") `stripDir` (MkPath "/lal/lad")     :: Maybe (Path Rel)
+-- Nothing
+-- >>> (MkPath "fad")          `stripDir` (MkPath "fad")          :: Maybe (Path Rel)
+-- Nothing
 stripDir :: MonadThrow m
-         => Path b t1 -> Path b t2 -> m (Path Rel t2)
+         => Path b -> Path b -> m (Path Rel)
 stripDir (MkPath p) (MkPath l) =
   case stripPrefix p' l of
     Nothing -> throwM (Couldn'tStripPrefixTPS p' l)
-    Just "" -> throwM (Couldn'tStripPrefixTPS p' l)
-    Just ok -> return (MkPath ok)
+    Just ok -> if BS.null ok
+                 then throwM (Couldn'tStripPrefixTPS p' l)
+                 else return (MkPath ok)
   where
-    p' = FilePath.addTrailingPathSeparator p
+    p' = addTrailingPathSeparator p
 
 -- | Is p a parent of the given location? Implemented in terms of
 -- 'stripDir'. The bases must match.
-isParentOf :: Path b t1 -> Path b t2 -> Bool
-isParentOf p l =
-  isJust (stripDir p l)
+--
+-- >>> (MkPath "/lal/lad")     `isParentOf` (MkPath "/lal/lad/fad")
+-- True
+-- >>> (MkPath "lal/lad")      `isParentOf` (MkPath "lal/lad/fad")
+-- True
+-- >>> (MkPath "/")            `isParentOf` (MkPath "/")
+-- False
+-- >>> (MkPath "/lal/lad/fad") `isParentOf` (MkPath "/lal/lad")
+-- False
+-- >>> (MkPath "fad")          `isParentOf` (MkPath "fad")
+-- False
+isParentOf :: Path b -> Path b -> Bool
+isParentOf p l = isJust (stripDir p l :: Maybe (Path Rel))
+
+
+-- |Get all parents of a path.
+--
+-- >>> getAllParents (MkPath "/abs/def/dod")
+-- ["/abs/def","/abs","/"]
+-- >>> getAllParents (MkPath "/")
+-- []
+getAllParents :: Path Abs -> [Path Abs]
+getAllParents (MkPath p)
+  | np == BS.singleton pathSeparator = []
+  | otherwise = dirname (MkPath np) : getAllParents (dirname $ MkPath np)
+  where
+    np = dropTrailingPathSeparator . normalise $ p
+
 
 -- | Extract the directory name of a path.
 --
@@ -371,45 +318,55 @@ isParentOf p l =
 --
 -- @dirname (p \<\/> a) == dirname p@
 --
-dirname :: Path Abs t -> Path Abs TPS
-dirname (MkPath fp) = MkPath (normalizeTPS (FilePath.takeDirectory $ FilePath.dropTrailingPathSeparator fp))
+-- >>> dirname (MkPath "/abc/def/dod")
+-- "/abc/def"
+-- >>> dirname (MkPath "/")
+-- "/"
+dirname :: Path Abs -> Path Abs
+dirname (MkPath fp) = MkPath (takeDirectory $ dropTrailingPathSeparator fp)
 
 -- | Extract the file part of a path.
 --
--- Throws InvalidRelTPS if it's passed e.g. '/', because there is no
--- basename for that and it would break the `Path Rel t` type.
 --
 -- The following properties hold:
 --
 -- @basename (p \<\/> a) == basename a@
 --
-basename :: MonadThrow m => Path b t -> m (Path Rel t)
+-- Throws: `PathException` if given the root path "/"
+--
+-- >>> basename (MkPath "/abc/def/dod") :: Maybe (Path Fn)
+-- Just "dod"
+-- >>> basename (MkPath "/")            :: Maybe (Path Fn)
+-- Nothing
+basename :: MonadThrow m => Path b -> m (Path Fn)
 basename (MkPath l)
-  | not (FilePath.isAbsolute rl) = return $ MkPath rl
-  | otherwise                    = throwM (InvalidRelTPS rl)
+  | not (isAbsolute rl) = return $ MkPath rl
+  | otherwise           = throwM RootDirHasNoBasename
   where
-    rl = case FilePath.hasTrailingPathSeparator l of
-           True  -> last (FilePath.splitPath l)
-           False -> normalizeNoTPS (FilePath.takeFileName l)
+    rl = last . splitPath . dropTrailingPathSeparator $ l
+
 
 --------------------------------------------------------------------------------
--- Internal functions
+-- Path IO helpers
 
--- | Internal use for normalizing a path while always adding
--- a trailing path separator.
-normalizeTPS :: FilePath -> FilePath
-normalizeTPS =
-  clean . FilePath.addTrailingPathSeparator . FilePath.normalise
-  where clean "./" = ""
-        clean ('/':'/':xs) = clean ('/':xs)
-        clean x = x
 
--- | Internal use for normalizing a path without adding or removing
--- a trailing path separator.
-normalizeNoTPS :: FilePath -> FilePath
-normalizeNoTPS =
-  clean . FilePath.normalise
-  where clean "./" = ""
-        clean ('/':'/':xs) = clean ('/':xs)
-        clean x = x
+withAbsPath :: Path Abs -> (ByteString -> IO a) -> IO a
+withAbsPath (MkPath p) action = action p
 
+
+withRelPath :: Path Rel -> (ByteString -> IO a) -> IO a
+withRelPath (MkPath p) action = action p
+
+
+withFnPath :: Path Fn -> (ByteString -> IO a) -> IO a
+withFnPath (MkPath p) action = action p
+
+
+------------------------
+-- ByteString helpers
+
+#if MIN_VERSION_bytestring(0,10,8)
+#else
+stripPrefix :: ByteString -> ByteString -> Maybe ByteString
+stripPrefix a b = BS.pack `fmap` L.stripPrefix (BS.unpack a) (BS.unpack b)
+#endif

src/HPath/IO.hs

@@ -0,0 +1,901 @@
+-- |
+-- Module      :  HPath.IO
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- This module provides high-level IO related file operations like
+-- copy, delete, move and so on. It only operates on /Path Abs/ which
+-- guarantees us well-typed paths which are absolute.
+--
+-- Some functions are just path-safe wrappers around
+-- unix functions, others have stricter exception handling
+-- and some implement functionality that doesn't have a unix
+-- counterpart (like `copyDirRecursive`).
+--
+-- Some of these operations are due to their nature __not atomic__, which
+-- means they may do multiple syscalls which form one context. Some
+-- of them also have to examine the filetypes explicitly before the
+-- syscalls, so a reasonable decision can be made. That means
+-- the result is undefined if another process changes that context
+-- while the non-atomic operation is still happening. However, where
+-- possible, as few syscalls as possible are used and the underlying
+-- exception handling is kept.
+--
+-- Note: `BlockDevice`, `CharacterDevice`, `NamedPipe` and `Socket`
+-- are ignored by some of the more high-level functions (like `easyCopy`).
+-- For other functions (like `copyFile`), the behavior on these file types is
+-- unreliable/unsafe. Check the documentation of those functions for details.
+
+{-# LANGUAGE PackageImports #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO
+  (
+  -- * Types
+    FileType(..)
+  , RecursiveErrorMode(..)
+  , CopyMode(..)
+  -- * File copying
+  , copyDirRecursive
+  , recreateSymlink
+  , copyFile
+  , easyCopy
+  -- * File deletion
+  , deleteFile
+  , deleteDir
+  , deleteDirRecursive
+  , easyDelete
+  -- * File opening
+  , openFile
+  , executeFile
+  -- * File creation
+  , createRegularFile
+  , createDir
+  , createSymlink
+  -- * File renaming/moving
+  , renameFile
+  , moveFile
+  -- * File permissions
+  , newFilePerms
+  , newDirPerms
+  -- * Directory reading
+  , getDirsFiles
+  -- * Filetype operations
+  , getFileType
+  -- * Others
+  , canonicalizePath
+  )
+  where
+
+
+import Control.Applicative
+  (
+    (<$>)
+  )
+import Control.Exception
+  (
+    IOException
+  , bracket
+  , throwIO
+  )
+import Control.Monad
+  (
+    unless
+  , void
+  , when
+  )
+import Data.ByteString
+  (
+    ByteString
+  )
+import Data.Foldable
+  (
+    for_
+  )
+import Data.IORef
+  (
+    IORef
+  , modifyIORef
+  , newIORef
+  , readIORef
+  )
+import Data.Maybe
+  (
+    catMaybes
+  )
+import Data.Word
+  (
+    Word8
+  )
+import Foreign.C.Error
+  (
+    eEXIST
+  , eINVAL
+  , eNOSYS
+  , eNOTEMPTY
+  , eXDEV
+  )
+import Foreign.C.Types
+  (
+    CSize
+  )
+import Foreign.Marshal.Alloc
+  (
+    allocaBytes
+  )
+import Foreign.Ptr
+  (
+    Ptr
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import HPath
+import HPath.Internal
+import HPath.IO.Errors
+import Prelude hiding (readFile)
+import System.IO.Error
+  (
+    catchIOError
+  , ioeGetErrorType
+  )
+import System.Linux.Sendfile
+  (
+    sendfileFd
+  , FileRange(..)
+  )
+import System.Posix.ByteString
+  (
+    exclusive
+  )
+import System.Posix.Directory.ByteString
+  (
+    createDirectory
+  , removeDirectory
+  )
+import System.Posix.Directory.Traversals
+  (
+    getDirectoryContents'
+  )
+import System.Posix.Files.ByteString
+  (
+    createSymbolicLink
+  , fileMode
+  , getFdStatus
+  , groupExecuteMode
+  , groupReadMode
+  , groupWriteMode
+  , otherExecuteMode
+  , otherReadMode
+  , otherWriteMode
+  , ownerModes
+  , ownerReadMode
+  , ownerWriteMode
+  , readSymbolicLink
+  , removeLink
+  , rename
+  , setFileMode
+  , unionFileModes
+  )
+import qualified System.Posix.Files.ByteString as PF
+import qualified "unix" System.Posix.IO.ByteString as SPI
+import qualified "unix-bytestring" System.Posix.IO.ByteString as SPB
+import System.Posix.FD
+  (
+    openFd
+  )
+import qualified System.Posix.Directory.Traversals as SPDT
+import qualified System.Posix.Directory.Foreign as SPDF
+import qualified System.Posix.Process.ByteString as SPP
+import System.Posix.Types
+  (
+    FileMode
+  , ProcessID
+  , Fd
+  )
+
+
+
+
+
+    -------------
+    --[ Types ]--
+    -------------
+
+
+data FileType = Directory
+              | RegularFile
+              | SymbolicLink
+              | BlockDevice
+              | CharacterDevice
+              | NamedPipe
+              | Socket
+  deriving (Eq, Show)
+
+
+
+-- |The error mode for any recursive operation.
+--
+-- 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.
+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
+
+
+
+
+    --------------------
+    --[ File Copying ]--
+    --------------------
+
+
+
+-- |Copies the contents of a directory recursively to the given destination.
+-- Does not follow symbolic links. This behaves more or less like:
+--
+-- @
+--   mkdir \/destination\/dir
+--   cp -R \/source\/dir\/* \/destination\/dir\/
+-- @
+--
+-- 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.
+--
+-- Note that there is no guaranteed ordering of the exceptions
+-- contained within `RecursiveFailure` in `CollectFailures` RecursiveErrorMode.
+--
+-- Safety/reliability concerns:
+--
+--    * not atomic
+--    * examines filetypes explicitly
+--    * an explicit check `throwDestinationInSource` is carried out for the
+--      top directory for basic sanity, because otherwise we might end up
+--      with an infinite copy loop... however, this operation is not
+--      carried out recursively (because it's slow)
+--
+-- Throws:
+--
+--    - `NoSuchThing` if source directory does not exist
+--    - `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)
+--    - `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
+copyDirRecursive :: Path Abs  -- ^ copy contents of this source dir
+                 -> Path Abs  -- ^ to this full destination (parent dirs
+                              --   are not automatically created)
+                 -> CopyMode
+                 -> RecursiveErrorMode
+                 -> IO ()
+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 ce fromp destdirp
+    collectedExceptions <- readIORef ce
+    unless (null collectedExceptions)
+           (throwIO . RecursiveFailure $ collectedExceptions)
+  where
+    go :: IORef [IOException] -> Path Abs -> Path Abs -> IO ()
+    go ce fromp' destdirp' = do
+
+      -- order is important here, so we don't get empty directories
+      -- on failure
+      contents <- handleIOE ce [] $ do
+        contents <- getDirsFiles fromp'
+
+        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
+
+      -- we can't use `easyCopy` 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 -> handleIOE ce ()
+                            $ recreateSymlink f newdest cm
+          Directory    -> go ce f newdest
+          RegularFile  -> handleIOE ce () $ copyFile f newdest cm
+          _            -> return ()
+    handleIOE :: IORef [IOException] -> a -> IO a -> IO a
+    handleIOE ce def = case rm of
+      FailEarly -> handleIOError throwIO
+      CollectFailures -> handleIOError (\e -> modifyIORef ce (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
+--    - `SameFile` if source and destination are the same file
+--      (`HPathIOException`)
+--
+--
+-- Throws in `Strict` mode only:
+--
+--    - `AlreadyExists` if destination file 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 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)
+
+
+-- |Copies the given regular file to the given destination.
+-- Neither follows symbolic links, nor accepts them.
+-- For "copying" symbolic links, use `recreateSymlink` instead.
+--
+-- Note that this is still sort of a low-level function and doesn't
+-- 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"
+--      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
+--
+-- Throws:
+--
+--    - `NoSuchThing` if source file does not exist
+--    - `NoSuchThing` if source file is a 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`)
+--
+-- Throws in `Strict` mode only:
+--
+--    - `AlreadyExists` if destination already exists
+--
+-- Note: calls `sendfile` and possibly `read`/`write` as fallback
+copyFile :: Path Abs  -- ^ source file
+         -> Path Abs  -- ^ destination file
+         -> CopyMode
+         -> IO ()
+copyFile from to cm = do
+  throwSameFile from to
+  
+  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]
+          -> [SPDF.Flags]
+          -> Path Abs  -- ^ source file
+          -> Path Abs  -- ^ destination file
+          -> IO ()
+_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.
+    withAbsPath to $ \to' -> withAbsPath from $ \from' ->
+      catchErrno [eINVAL, eNOSYS]
+                 (sendFileCopy from' to')
+                 (void $ readWriteCopy from' to')
+  where
+    copyWith copyAction source dest =
+      bracket (openFd source SPI.ReadOnly sflags Nothing)
+              SPI.closeFd
+              $ \sfd -> do
+                fileM <- System.Posix.Files.ByteString.fileMode
+                         <$> getFdStatus sfd
+                bracketeer (openFd dest SPI.WriteOnly
+                             dflags $ Just fileM)
+                           SPI.closeFd
+                           (\fd -> SPI.closeFd fd >> deleteFile to)
+                           $ \dfd -> copyAction sfd dfd
+    -- this is low-level stuff utilizing sendfile(2) for speed
+    sendFileCopy :: ByteString -> ByteString -> IO ()
+    sendFileCopy = copyWith
+      (\sfd dfd -> sendfileFd dfd sfd EntireFile $ return ())
+    -- low-level copy operation utilizing read(2)/write(2)
+    -- in case `sendFileCopy` fails/is unsupported
+    readWriteCopy :: ByteString -> ByteString -> IO Int
+    readWriteCopy = copyWith
+      (\sfd dfd -> allocaBytes (fromIntegral bufSize)
+                     $ \buf -> write' sfd dfd buf 0)
+      where
+        bufSize :: CSize
+        bufSize = 8192
+        write' :: Fd -> Fd -> Ptr Word8 -> Int -> IO Int
+        write' sfd dfd buf totalsize = do
+            size <- SPB.fdReadBuf sfd buf bufSize
+            if size == 0
+              then return $ fromIntegral totalsize
+              else do rsize <- SPB.fdWriteBuf dfd buf size
+                      when (rsize /= size) (throwIO . CopyFailed
+                                            $ "wrong size!")
+                      write' sfd dfd buf (totalsize + fromIntegral size)
+
+
+-- |Copies a regular file, directory or symbolic link. In case of a
+-- symbolic link it is just recreated, even if it points to a directory.
+-- Any other file type is ignored.
+--
+-- Safety/reliability concerns:
+--
+--    * examines filetypes explicitly
+--    * calls `copyDirRecursive` for directories
+easyCopy :: Path Abs
+         -> Path Abs
+         -> CopyMode
+         -> RecursiveErrorMode
+         -> IO ()
+easyCopy from to cm rm = do
+  ftype <- getFileType from
+  case ftype of
+       SymbolicLink -> recreateSymlink from to cm
+       RegularFile  -> copyFile from to cm
+       Directory    -> copyDirRecursive from to cm rm
+       _            -> return ()
+
+
+
+
+
+    ---------------------
+    --[ File Deletion ]--
+    ---------------------
+
+
+-- |Deletes the given file. Raises `eISDIR`
+-- if run on a directory. Does not follow symbolic links.
+--
+-- Throws:
+--
+--    - `InappropriateType` for wrong file type (directory)
+--    - `NoSuchThing` if the file does not exist
+--    - `PermissionDenied` if the directory cannot be read
+deleteFile :: Path Abs -> IO ()
+deleteFile p = withAbsPath p removeLink
+
+
+-- |Deletes the given directory, which must be empty, never symlinks.
+--
+-- Throws:
+--
+--    - `InappropriateType` for wrong file type (symlink to directory)
+--    - `InappropriateType` for wrong file type (regular file)
+--    - `NoSuchThing` if directory does not exist
+--    - `UnsatisfiedConstraints` if directory is not empty
+--    - `PermissionDenied` if we can't open or write to parent directory
+--
+-- Notes: calls `rmdir`
+deleteDir :: Path Abs -> IO ()
+deleteDir p = withAbsPath p removeDirectory
+
+
+-- |Deletes the given directory recursively. Does not follow symbolic
+-- links. Tries `deleteDir` first before attemtping a recursive
+-- deletion.
+--
+-- On directory contents this behaves like `easyDelete`
+-- and thus will ignore any file type that is not `RegularFile`,
+-- `SymbolicLink` or `Directory`.
+--
+-- Safety/reliability concerns:
+--
+--    * not atomic
+--    * examines filetypes explicitly
+--
+-- Throws:
+--
+--    - `InappropriateType` for wrong file type (symlink to directory)
+--    - `InappropriateType` for wrong file type (regular file)
+--    - `NoSuchThing` if directory does not exist
+--    - `PermissionDenied` if we can't open or write to parent directory
+deleteDirRecursive :: Path Abs -> IO ()
+deleteDirRecursive p =
+  catchErrno [eNOTEMPTY, eEXIST]
+             (deleteDir p)
+    $ do
+      files <- getDirsFiles p
+      for_ files $ \file -> do
+        ftype <- getFileType file
+        case ftype of
+          SymbolicLink -> deleteFile file
+          Directory    -> deleteDirRecursive file
+          RegularFile  -> deleteFile file
+          _            -> return ()
+      removeDirectory . toFilePath $ p
+
+
+-- |Deletes a file, directory or symlink.
+-- In case of directory, performs recursive deletion. In case of
+-- a symlink, the symlink file is deleted.
+-- Any other file type is ignored.
+--
+-- Safety/reliability concerns:
+--
+--    * examines filetypes explicitly
+--    * calls `deleteDirRecursive` for directories
+easyDelete :: Path Abs -> IO ()
+easyDelete p = do
+  ftype <- getFileType p
+  case ftype of
+    SymbolicLink -> deleteFile p
+    Directory    -> deleteDirRecursive p
+    RegularFile  -> deleteFile p
+    _            -> return ()
+
+
+
+
+    --------------------
+    --[ File Opening ]--
+    --------------------
+
+
+-- |Opens a file appropriately by invoking xdg-open. The file type
+-- is not checked. This forks a process.
+openFile :: Path Abs
+         -> IO ProcessID
+openFile p =
+  withAbsPath p $ \fp ->
+    SPP.forkProcess $ SPP.executeFile "xdg-open" True [fp] Nothing
+
+
+-- |Executes a program with the given arguments. This forks a process.
+executeFile :: Path Abs        -- ^ program
+            -> [ByteString]    -- ^ arguments
+            -> IO ProcessID
+executeFile fp args
+  = withAbsPath fp $ \fpb ->
+      SPP.forkProcess
+      $ SPP.executeFile fpb True args Nothing
+
+
+
+
+    ---------------------
+    --[ File Creation ]--
+    ---------------------
+
+
+-- |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 :: FileMode -> Path Abs -> IO ()
+createRegularFile fm dest =
+  bracket (SPI.openFd (fromAbs dest) SPI.WriteOnly (Just fm)
+                      (SPI.defaultFileFlags { exclusive = True }))
+          SPI.closeFd
+          (\_ -> return ())
+
+
+-- |Create an empty directory at the given directory with the given filename.
+--
+-- Throws:
+--
+--    - `PermissionDenied` if output directory cannot be written to
+--    - `AlreadyExists` if destination directory already exists
+createDir :: FileMode -> Path Abs -> IO ()
+createDir fm dest = createDirectory (fromAbs dest) fm
+
+
+-- |Create a symlink.
+--
+-- Throws:
+--
+--    - `PermissionDenied` if output directory cannot be written to
+--    - `AlreadyExists` if destination file already exists
+--
+-- Note: calls `symlink`
+createSymlink :: Path Abs   -- ^ destination file
+              -> ByteString -- ^ path the symlink points to
+              -> IO ()
+createSymlink dest sympoint
+  = createSymbolicLink sympoint (fromAbs dest)
+
+
+
+    ----------------------------
+    --[ File Renaming/Moving ]--
+    ----------------------------
+
+
+-- |Rename a given file with the provided filename. Destination and source
+-- must be on the same device, otherwise `eXDEV` will be raised.
+--
+-- Does not follow symbolic links, but renames the symbolic link file.
+--
+-- Safety/reliability concerns:
+--
+--    * has a separate set of exception handling, apart from the syscall
+--
+-- Throws:
+--
+--     - `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`)
+--
+-- Note: calls `rename` (but does not allow to rename over existing files)
+renameFile :: Path Abs -> Path Abs -> IO ()
+renameFile fromf tof = do
+  throwSameFile fromf tof
+  throwFileDoesExist tof
+  throwDirDoesExist tof
+  rename (fromAbs fromf) (fromAbs tof)
+
+
+-- |Move a file. This also works across devices by copy-delete fallback.
+-- And also works on directories.
+--
+-- Does not follow symbolic links, but renames the symbolic link file.
+--
+--
+-- 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
+--     - `SameFile` if destination and source are the same file
+--       (`HPathIOException`)
+--
+-- Throws in `Strict` mode only:
+--
+--    - `FileDoesExist` if destination file already exists (`HPathIOException`)
+--    - `DirDoesExist` if destination directory already exists
+--      (`HPathIOException`)
+--
+-- 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 cm = do
+  throwSameFile from to
+  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
+
+
+
+
+
+
+    -----------------------
+    --[ File Permissions]--
+    -----------------------
+
+
+-- |Default permissions for a new file.
+newFilePerms :: FileMode
+newFilePerms
+  =                  ownerWriteMode
+    `unionFileModes` ownerReadMode
+    `unionFileModes` groupWriteMode
+    `unionFileModes` groupReadMode
+    `unionFileModes` otherWriteMode
+    `unionFileModes` otherReadMode
+
+
+-- |Default permissions for a new directory.
+newDirPerms :: FileMode
+newDirPerms
+  =                  ownerModes
+    `unionFileModes` groupExecuteMode
+    `unionFileModes` groupReadMode
+    `unionFileModes` otherExecuteMode
+    `unionFileModes` otherReadMode
+
+
+
+    -------------------------
+    --[ Directory reading ]--
+    -------------------------
+
+
+-- |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
+--     - `InappropriateType` if file type is wrong (file)
+--     - `InappropriateType` if file type is wrong (symlink to file)
+--     - `InappropriateType` if file type is wrong (symlink to dir)
+--     - `PermissionDenied` if directory cannot be opened
+getDirsFiles :: Path Abs        -- ^ dir to read
+             -> IO [Path Abs]
+getDirsFiles p =
+  withAbsPath p $ \fp -> do
+    fd <- openFd fp SPI.ReadOnly [SPDF.oNofollow] Nothing
+    return
+      . catMaybes
+      .   fmap (\x -> (</>) p <$> (parseMaybe . snd $ x))
+      =<< getDirectoryContents' fd
+  where
+    parseMaybe :: ByteString -> Maybe (Path Fn)
+    parseMaybe = parseFn
+
+
+
+
+    ---------------------------
+    --[ FileType operations ]--
+    ---------------------------
+
+
+-- |Get the file type of the file located at the given path. Does
+-- not follow symbolic links.
+--
+-- Throws:
+--
+--    - `NoSuchThing` if the file does not exist
+--    - `PermissionDenied` if any part of the path is not accessible
+getFileType :: Path Abs -> IO FileType
+getFileType p = do
+  fs <- PF.getSymbolicLinkStatus (fromAbs p)
+  decide fs
+  where
+    decide fs
+      | PF.isDirectory fs       = return Directory
+      | PF.isRegularFile fs     = return RegularFile
+      | PF.isSymbolicLink fs    = return SymbolicLink
+      | PF.isBlockDevice fs     = return BlockDevice
+      | PF.isCharacterDevice fs = return CharacterDevice
+      | PF.isNamedPipe fs       = return NamedPipe
+      | PF.isSocket fs          = return Socket
+      | otherwise               = ioError $ userError "No filetype?!"
+
+
+
+    --------------
+    --[ Others ]--
+    --------------
+
+
+
+-- |Applies `realpath` on the given absolute path.
+--
+-- Throws:
+--
+--    - `NoSuchThing` if the file at the given path does not exist
+--    - `NoSuchThing` if the symlink is broken
+canonicalizePath :: Path Abs -> IO (Path Abs)
+canonicalizePath (MkPath l) = do
+  nl <- SPDT.realpath l
+  return $ MkPath nl

src/HPath/IO.hs-boot

@@ -0,0 +1,7 @@
+module HPath.IO where
+
+
+import HPath
+
+canonicalizePath :: Path Abs -> IO (Path Abs)
+

src/HPath/IO/Errors.hs

@@ -0,0 +1,373 @@
+-- |
+-- Module      :  HPath.IO.Errors
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- Provides error handling.
+
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HPath.IO.Errors
+  (
+  -- * Types
+    HPathIOException(..)
+
+  -- * Exception identifiers
+  , isFileDoesNotExist
+  , isDirDoesNotExist
+  , isSameFile
+  , isDestinationInSource
+  , isFileDoesExist
+  , isDirDoesExist
+  , isInvalidOperation
+  , isCan'tOpenDirectory
+  , isCopyFailed
+  , isRecursiveFailure
+
+  -- * Path based functions
+  , throwFileDoesExist
+  , throwDirDoesExist
+  , throwFileDoesNotExist
+  , throwDirDoesNotExist
+  , throwSameFile
+  , sameFile
+  , throwDestinationInSource
+  , doesFileExist
+  , doesDirectoryExist
+  , isWritable
+  , canOpenDirectory
+  , throwCantOpenDirectory
+
+  -- * Error handling functions
+  , catchErrno
+  , rethrowErrnoAs
+  , handleIOError
+  , bracketeer
+  , reactOnError
+  )
+  where
+
+
+import Control.Applicative
+  (
+    (<$>)
+  )
+import Control.Exception
+import Control.Monad
+  (
+    forM
+  , when
+  )
+import Data.ByteString
+  (
+    ByteString
+  )
+import Data.ByteString.UTF8
+  (
+    toString
+  )
+import Data.Typeable
+import Foreign.C.Error
+  (
+    getErrno
+  , Errno
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType
+  )
+import HPath
+import {-# SOURCE #-} HPath.IO
+  (
+    canonicalizePath
+  )
+import HPath.IO.Utils
+import System.IO.Error
+  (
+    catchIOError
+  , ioeGetErrorType
+  )
+
+import qualified System.Posix.Directory.ByteString as PFD
+import System.Posix.Files.ByteString
+  (
+    fileAccess
+  , getFileStatus
+  )
+import qualified System.Posix.Files.ByteString as PF
+
+
+data HPathIOException = FileDoesNotExist ByteString
+                      | DirDoesNotExist ByteString
+                      | SameFile ByteString ByteString
+                      | DestinationInSource ByteString ByteString
+                      | FileDoesExist ByteString
+                      | DirDoesExist ByteString
+                      | InvalidOperation String
+                      | Can'tOpenDirectory ByteString
+                      | CopyFailed String
+                      | RecursiveFailure [IOException]
+  deriving (Typeable, Eq)
+
+
+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
+  show (RecursiveFailure exs) = "Recursive operation failed: "
+    ++ show exs
+
+
+toConstr :: HPathIOException -> String
+toConstr FileDoesNotExist {} = "FileDoesNotExist"
+toConstr DirDoesNotExist {} = "DirDoesNotExist"
+toConstr SameFile {} = "SameFile"
+toConstr DestinationInSource {} = "DestinationInSource"
+toConstr FileDoesExist {} = "FileDoesExist"
+toConstr DirDoesExist {} = "DirDoesExist"
+toConstr InvalidOperation {} = "InvalidOperation"
+toConstr Can'tOpenDirectory {} = "Can'tOpenDirectory"
+toConstr CopyFailed {} = "CopyFailed"
+toConstr RecursiveFailure {} = "RecursiveFailure"
+
+
+
+
+instance Exception HPathIOException
+
+
+
+
+
+    -----------------------------
+    --[ Exception identifiers ]--
+    -----------------------------
+
+isFileDoesNotExist, isDirDoesNotExist, isSameFile, isDestinationInSource, isFileDoesExist, isDirDoesExist, isInvalidOperation, isCan'tOpenDirectory, isCopyFailed, isRecursiveFailure :: HPathIOException -> Bool
+isFileDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr FileDoesNotExist{}
+isDirDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr DirDoesNotExist{}
+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{}
+
+
+
+    ----------------------------
+    --[ Path based functions ]--
+    ----------------------------
+
+
+throwFileDoesExist :: Path Abs -> IO ()
+throwFileDoesExist fp =
+  whenM (doesFileExist fp) (throwIO . FileDoesExist
+                                    . fromAbs $ fp)
+
+
+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)
+
+
+-- |Uses `isSameFile` and throws `SameFile` if it returns True.
+throwSameFile :: Path Abs
+              -> Path Abs
+              -> IO ()
+throwSameFile fp1 fp2 =
+  whenM (sameFile fp1 fp2)
+        (throwIO $ SameFile (fromAbs fp1) (fromAbs fp2))
+
+
+-- |Check if the files are the same by examining device and file id.
+-- This follows symbolic links.
+sameFile :: Path Abs -> Path Abs -> IO Bool
+sameFile fp1 fp2 =
+  withAbsPath fp1 $ \fp1' -> withAbsPath fp2 $ \fp2' ->
+    handleIOError (\_ -> return False) $ do
+      fs1 <- getFileStatus fp1'
+      fs2 <- getFileStatus fp2'
+
+      if ((PF.deviceID fs1, PF.fileID fs1) ==
+          (PF.deviceID fs2, PF.fileID fs2))
+        then return True
+        else return False
+
+
+-- TODO: make this more robust when destination does not exist
+-- |Checks whether the destination directory is contained
+-- within the source directory by comparing the device+file ID of the
+-- source directory with all device+file IDs of the parent directories
+-- of the destination.
+throwDestinationInSource :: Path Abs -- ^ source dir
+                         -> Path Abs -- ^ full destination, @dirname dest@
+                                     --   must exist
+                         -> IO ()
+throwDestinationInSource source dest = do
+  dest'   <- (\x -> maybe x (\y -> x </> y) $ basename dest)
+             <$> (canonicalizePath $ dirname dest)
+  dids <- forM (getAllParents dest') $ \p -> do
+          fs <- PF.getSymbolicLinkStatus (fromAbs p)
+          return (PF.deviceID fs, PF.fileID fs)
+  sid <- fmap (\x -> (PF.deviceID x, PF.fileID x))
+              $ PF.getFileStatus (fromAbs source)
+  when (elem sid dids)
+       (throwIO $ DestinationInSource (fromAbs dest)
+                                      (fromAbs source))
+
+
+-- |Checks if the given file exists and is not a directory.
+-- Does not follow symlinks.
+doesFileExist :: Path Abs -> IO Bool
+doesFileExist fp =
+  handleIOError (\_ -> return False) $ do
+    fs  <- PF.getSymbolicLinkStatus (fromAbs fp)
+    return $ not . PF.isDirectory $ fs
+
+
+-- |Checks if the given file exists and is a directory.
+-- Does not follow symlinks.
+doesDirectoryExist :: Path Abs -> IO Bool
+doesDirectoryExist fp =
+  handleIOError (\_ -> return False) $ do
+    fs  <- PF.getSymbolicLinkStatus (fromAbs fp)
+    return $ PF.isDirectory fs
+
+
+-- |Checks whether a file or folder is writable.
+isWritable :: Path Abs -> IO Bool
+isWritable fp =
+  handleIOError (\_ -> return False) $
+    fileAccess (fromAbs fp) False True False
+
+
+-- |Checks whether the directory at the given path exists and can be
+-- opened. This invokes `openDirStream` which follows symlinks.
+canOpenDirectory :: Path Abs -> IO Bool
+canOpenDirectory fp =
+  handleIOError (\_ -> return False) $ do
+    bracket (PFD.openDirStream . fromAbs $ fp)
+            PFD.closeDirStream
+            (\_ -> return ())
+    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)
+
+
+
+    --------------------------------
+    --[ Error handling functions ]--
+    --------------------------------
+
+
+-- |Carries out an action, then checks if there is an IOException and
+-- a specific errno. If so, then it carries out another action, otherwise
+-- it rethrows the error.
+catchErrno :: [Errno] -- ^ errno to catch
+           -> IO a    -- ^ action to try, which can raise an IOException
+           -> IO a    -- ^ action to carry out in case of an IOException and
+                      --   if errno matches
+           -> IO a
+catchErrno en a1 a2 =
+  catchIOError a1 $ \e -> do
+    errno <- getErrno
+    if errno `elem` en
+      then a2
+      else ioError e
+
+
+-- |Execute the given action and retrow IO exceptions as a new Exception
+-- that have the given errno. If errno does not match the exception is rethrown
+-- as is.
+rethrowErrnoAs :: Exception e
+               => [Errno]       -- ^ errno to catch
+               -> e             -- ^ rethrow as if errno matches
+               -> IO a          -- ^ action to try
+               -> IO a
+rethrowErrnoAs en fmex action = catchErrno en action (throwIO fmex)
+
+
+
+-- |Like `catchIOError`, with arguments swapped.
+handleIOError :: (IOError -> IO a) -> IO a -> IO a
+handleIOError = flip catchIOError
+
+
+-- |Like `bracket`, but allows to have different clean-up
+-- actions depending on whether the in-between computation
+-- has raised an exception or not. 
+bracketeer :: IO a        -- ^ computation to run first
+           -> (a -> IO b) -- ^ computation to run last, when
+                          --   no exception was raised
+           -> (a -> IO b) -- ^ computation to run last,
+                          --   when an exception was raised
+           -> (a -> IO c) -- ^ computation to run in-between
+           -> IO c
+bracketeer before after afterEx thing =
+  mask $ \restore -> do
+    a <- before
+    r <- restore (thing a) `onException` afterEx a
+    _ <- after a
+    return r
+
+
+reactOnError :: IO a
+             -> [(IOErrorType, IO a)]      -- ^ reaction on IO errors
+             -> [(HPathIOException, IO a)] -- ^ reaction on HPathIOException
+             -> IO a
+reactOnError a ios fmios =
+  a `catches` [iohandler, fmiohandler]
+  where
+    iohandler = Handler $
+      \(ex :: IOException) ->
+         foldr (\(t, a') y -> if ioeGetErrorType ex == t
+                                then a'
+                                else y)
+               (throwIO ex)
+               ios
+    fmiohandler = Handler $
+      \(ex :: HPathIOException) ->
+         foldr (\(t, a') y -> if toConstr ex == toConstr t
+                                then a'
+                                else y)
+               (throwIO ex)
+               fmios

src/HPath/IO/Utils.hs

@@ -0,0 +1,32 @@
+-- |
+-- Module      :  HPath.IO.Utils
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- 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)

src/HPath/Internal.hs

@@ -7,44 +7,45 @@ module HPath.Internal
   where
 
 import Control.DeepSeq (NFData (..))
+import Data.ByteString (ByteString)
 import Data.Data
 
 -- | Path of some base and type.
 --
--- Internally is a string. The string can be of two formats only:
+-- Internally is a ByteString. The ByteString can be of two formats only:
 --
 -- 1. without trailing path separator: @file.txt@, @foo\/bar.txt@, @\/foo\/bar.txt@
 -- 2. with trailing path separator: @foo\/@, @\/foo\/bar\/@
 --
 -- There are no duplicate
 -- path separators @\/\/@, no @..@, no @.\/@, no @~\/@, etc.
-data Path b t = MkPath FilePath
+data Path b = MkPath ByteString
   deriving (Typeable)
 
--- | String equality.
+-- | ByteString equality.
 --
 -- The following property holds:
 --
 -- @show x == show y ≡ x == y@
-instance Eq (Path b t) where
+instance Eq (Path b) where
   (==) (MkPath x) (MkPath y) = x == y
 
--- | String ordering.
+-- | ByteString ordering.
 --
 -- The following property holds:
 --
 -- @show x \`compare\` show y ≡ x \`compare\` y@
-instance Ord (Path b t) where
+instance Ord (Path b) where
   compare (MkPath x) (MkPath y) = compare x y
 
--- | Same as 'Path.toFilePath'.
+-- | Same as 'HPath.toFilePath'.
 --
 -- The following property holds:
 --
 -- @x == y ≡ show x == show y@
-instance Show (Path b t) where
+instance Show (Path b) where
   show (MkPath x) = show x
 
-instance NFData (Path b t) where
+instance NFData (Path b) where
   rnf (MkPath x) = rnf x
 

src/System/Posix/Directory/Foreign.hsc

@@ -0,0 +1,55 @@
+module System.Posix.Directory.Foreign where
+
+import Data.Bits
+import Data.List (foldl')
+import Foreign.C.Types
+
+#include <limits.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+newtype DirType = DirType Int deriving (Eq, Show)
+data Flags = Flags Int | UnsupportedFlag String deriving (Eq, Show)
+
+unFlags :: Flags -> Int
+unFlags (Flags i) = i
+unFlags (UnsupportedFlag name) = error (name ++ " is not supported on this platform")
+
+-- |Returns @True@ if posix-paths was compiled with support for the provided
+-- flag. (As of this writing, the only flag for which this check may be
+-- necessary is 'oCloexec'; all other flags will always yield @True@.)
+isSupported :: Flags -> Bool
+isSupported (Flags _) = True
+isSupported _ = False
+
+-- |@O_CLOEXEC@ is not supported on every POSIX platform. Use
+-- @'isSupported' oCloexec@ to determine if support for @O_CLOEXEC@ was
+-- compiled into your version of posix-paths. (If not, using @oCloexec@ will
+-- throw an exception.)
+oCloexec :: Flags
+#ifdef O_CLOEXEC
+oCloexec = Flags #{const O_CLOEXEC}
+#else
+{-# WARNING oCloexec
+    "This version of posix-paths was compiled without @O_CLOEXEC@ support." #-}
+oCloexec = UnsupportedFlag "O_CLOEXEC"
+#endif
+
+
+
+-- If these enum declarations occur earlier in the file, haddock
+-- gets royally confused about the above doc comments.
+-- Probably http://trac.haskell.org/haddock/ticket/138
+
+#{enum DirType, DirType, DT_BLK, DT_CHR, DT_DIR, DT_FIFO, DT_LNK, DT_REG, DT_SOCK, DT_UNKNOWN}
+
+#{enum Flags, Flags, O_APPEND, O_ASYNC, O_CREAT, O_DIRECTORY, O_EXCL, O_NOCTTY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY, O_WRONLY, O_RDWR, O_SYNC, O_TRUNC}
+
+pathMax :: Int
+pathMax = #{const PATH_MAX}
+
+unionFlags :: [Flags] -> CInt
+unionFlags = fromIntegral . foldl' ((. unFlags) . (.|.)) 0

src/System/Posix/Directory/Traversals.hs

@@ -0,0 +1,264 @@
+-- |
+-- Module      :  System.Posix.Directory.Traversals
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- Traversal and read operations on directories.
+
+
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PackageImports #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE ViewPatterns #-}
+
+{-# OPTIONS_GHC -Wall #-}
+
+
+module System.Posix.Directory.Traversals (
+
+  getDirectoryContents
+, getDirectoryContents'
+
+, allDirectoryContents
+, allDirectoryContents'
+, traverseDirectory
+
+-- lower-level stuff
+, readDirEnt
+, packDirStream
+, unpackDirStream
+, fdOpendir
+
+, realpath
+) where
+
+
+#if __GLASGOW_HASKELL__ < 710
+import Control.Applicative ((<$>))
+#endif
+import Control.Monad
+import System.Posix.FilePath ((</>))
+import System.Posix.Directory.Foreign
+
+import qualified System.Posix as Posix
+import System.IO.Error
+import Control.Exception
+import qualified Data.ByteString.Char8 as BS
+import System.Posix.ByteString.FilePath
+import System.Posix.Directory.ByteString as PosixBS
+import System.Posix.Files.ByteString
+
+import System.IO.Unsafe
+import "unix" System.Posix.IO.ByteString (closeFd)
+import Unsafe.Coerce (unsafeCoerce)
+import Foreign.C.Error
+import Foreign.C.String
+import Foreign.C.Types
+import Foreign.Marshal.Alloc (alloca,allocaBytes)
+import Foreign.Ptr
+import Foreign.Storable
+
+
+
+
+----------------------------------------------------------
+
+-- | Get all files from a directory and its subdirectories.
+--
+-- Upon entering a directory, 'allDirectoryContents' will get all entries
+-- strictly.  However the returned list is lazy in that directories will only
+-- be accessed on demand.
+--
+-- Follows symbolic links for the input dir.
+allDirectoryContents :: RawFilePath -> IO [RawFilePath]
+allDirectoryContents topdir = do
+    namesAndTypes <- getDirectoryContents topdir
+    let properNames = filter ((`notElem` [".", ".."]) . snd) namesAndTypes
+    paths <- forM properNames $ \(typ,name) -> unsafeInterleaveIO $ do
+        let path = topdir </> name
+        case () of
+            () | typ == dtDir -> allDirectoryContents path
+               | typ == dtUnknown -> do
+                    isDir <- isDirectory <$> getFileStatus path
+                    if isDir
+                        then allDirectoryContents path
+                        else return [path]
+               | otherwise -> return [path]
+    return (topdir : concat paths)
+
+-- | Get all files from a directory and its subdirectories strictly.
+--
+-- Follows symbolic links for the input dir.
+allDirectoryContents' :: RawFilePath -> IO [RawFilePath]
+allDirectoryContents' = fmap reverse . traverseDirectory (\acc fp -> return (fp:acc)) []
+-- this uses traverseDirectory because it's more efficient than forcing the
+-- lazy version.
+
+-- | Recursively apply the 'action' to the parent directory and all
+-- files/subdirectories.
+--
+-- This function allows for memory-efficient traversals.
+--
+-- Follows symbolic links for the input dir.
+traverseDirectory :: (s -> RawFilePath -> IO s) -> s -> RawFilePath -> IO s
+traverseDirectory act s0 topdir = toploop
+  where
+    toploop = do
+        isDir <- isDirectory <$> getFileStatus topdir
+        s' <- act s0 topdir
+        if isDir then actOnDirContents topdir s' loop
+                 else return s'
+    loop typ path acc = do
+        isDir <- case () of
+            () | typ == dtDir     -> return True
+               | typ == dtUnknown -> isDirectory <$> getFileStatus path
+               | otherwise        -> return False
+        if isDir
+          then act acc path >>= \acc' -> actOnDirContents path acc' loop
+          else act acc path
+
+actOnDirContents :: RawFilePath
+                 -> b
+                 -> (DirType -> RawFilePath -> b -> IO b)
+                 -> IO b
+actOnDirContents pathRelToTop b f =
+  modifyIOError ((`ioeSetFileName` (BS.unpack pathRelToTop)) .
+                 (`ioeSetLocation` "findBSTypRel")) $
+    bracket
+      (openDirStream pathRelToTop)
+      Posix.closeDirStream
+      (\dirp -> loop dirp b)
+ where
+  loop dirp b' = do
+    (typ,e) <- readDirEnt dirp
+    if (e == "")
+      then return b'
+      else
+          if (e == "." || e == "..")
+              then loop dirp b'
+              else f typ (pathRelToTop </> e) b' >>= loop dirp
+
+
+----------------------------------------------------------
+-- dodgy stuff
+
+type CDir = ()
+type CDirent = ()
+
+-- Posix doesn't export DirStream, so to re-use that type we need to use
+-- unsafeCoerce.  It's just a newtype, so this is a legitimate usage.
+-- ugly trick.
+unpackDirStream :: DirStream -> Ptr CDir
+unpackDirStream = unsafeCoerce
+
+packDirStream :: Ptr CDir -> DirStream
+packDirStream = unsafeCoerce
+
+-- the __hscore_* functions are defined in the unix package.  We can import them and let
+-- the linker figure it out.
+foreign import ccall unsafe "__hscore_readdir"
+  c_readdir  :: Ptr CDir -> Ptr (Ptr CDirent) -> IO CInt
+
+foreign import ccall unsafe "__hscore_free_dirent"
+  c_freeDirEnt  :: Ptr CDirent -> IO ()
+
+foreign import ccall unsafe "__hscore_d_name"
+  c_name :: Ptr CDirent -> IO CString
+
+foreign import ccall unsafe "__posixdir_d_type"
+  c_type :: Ptr CDirent -> IO DirType
+
+foreign import ccall "realpath"
+  c_realpath :: CString -> CString -> IO CString
+
+foreign import ccall unsafe "fdopendir"
+  c_fdopendir :: Posix.Fd -> IO (Ptr ())
+
+----------------------------------------------------------
+-- less dodgy but still lower-level
+
+
+readDirEnt :: DirStream -> IO (DirType, RawFilePath)
+readDirEnt (unpackDirStream -> dirp) =
+  alloca $ \ptr_dEnt  -> loop ptr_dEnt
+ where
+  loop ptr_dEnt = do
+    resetErrno
+    r <- c_readdir dirp ptr_dEnt
+    if (r == 0)
+       then do
+         dEnt <- peek ptr_dEnt
+         if (dEnt == nullPtr)
+            then return (dtUnknown,BS.empty)
+            else do
+                 dName <- c_name dEnt >>= peekFilePath
+                 dType <- c_type dEnt
+                 c_freeDirEnt dEnt
+                 return (dType, dName)
+       else do
+         errno <- getErrno
+         if (errno == eINTR)
+            then loop ptr_dEnt
+            else do
+                 let (Errno eo) = errno
+                 if (eo == 0)
+                    then return (dtUnknown,BS.empty)
+                    else throwErrno "readDirEnt"
+
+
+-- |Gets all directory contents (not recursively).
+getDirectoryContents :: RawFilePath -> IO [(DirType, RawFilePath)]
+getDirectoryContents path =
+  modifyIOError ((`ioeSetFileName` (BS.unpack path)) .
+                 (`ioeSetLocation` "System.Posix.Directory.Traversals.getDirectoryContents")) $
+    bracket
+      (PosixBS.openDirStream path)
+      PosixBS.closeDirStream
+      _dirloop
+
+
+-- |Binding to @fdopendir(3)@.
+fdOpendir :: Posix.Fd -> IO DirStream
+fdOpendir fd =
+    packDirStream <$> throwErrnoIfNull "fdOpendir" (c_fdopendir fd)
+
+
+-- |Like `getDirectoryContents` except for a file descriptor.
+--
+-- To avoid complicated error checks, the file descriptor is
+-- __always__ closed, even if `fdOpendir` fails. Usually, this
+-- only happens on successful `fdOpendir` and after the directory
+-- stream is closed. Also see the manpage of @fdopendir(3)@ for
+-- more details.
+getDirectoryContents' :: Posix.Fd -> IO [(DirType, RawFilePath)]
+getDirectoryContents' fd = do
+  dirstream <- fdOpendir fd `catchIOError` \e -> do
+    closeFd fd
+    ioError e
+  -- closeDirStream closes the filedescriptor
+  finally (_dirloop dirstream) (PosixBS.closeDirStream dirstream)
+
+
+_dirloop :: DirStream -> IO [(DirType, RawFilePath)]
+{-# INLINE _dirloop #-}
+_dirloop dirp = do
+   t@(_typ,e) <- readDirEnt dirp
+   if BS.null e then return [] else do
+     es <- _dirloop dirp
+     return (t:es)
+
+
+-- | return the canonicalized absolute pathname
+--
+-- like canonicalizePath, but uses @realpath(3)@
+realpath :: RawFilePath -> IO RawFilePath
+realpath inp =
+    allocaBytes pathMax $ \tmp -> do
+        void $ BS.useAsCString inp $ \cstr -> throwErrnoIfNull "realpath" $ c_realpath cstr tmp
+        BS.packCString tmp

src/System/Posix/FD.hs

@@ -0,0 +1,75 @@
+-- |
+-- Module      :  System.Posix.FD
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- Provides an alternative for `System.Posix.IO.ByteString.openFd`
+-- which gives us more control on what status flags to pass to the
+-- low-level @open(2)@ call, in contrast to the unix package.
+
+
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TupleSections #-}
+
+{-# OPTIONS_GHC -Wall #-}
+
+
+module System.Posix.FD (
+    openFd
+) where
+
+
+import Foreign.C.String
+import Foreign.C.Types
+import System.Posix.Directory.Foreign
+import qualified System.Posix as Posix
+import System.Posix.ByteString.FilePath
+
+
+foreign import ccall unsafe "open"
+   c_open :: CString -> CInt -> Posix.CMode -> IO CInt
+
+
+open_  :: CString
+       -> Posix.OpenMode
+       -> [Flags]
+       -> Maybe Posix.FileMode
+       -> IO Posix.Fd
+open_ str how optional_flags maybe_mode = do
+    fd <- c_open str all_flags mode_w
+    return (Posix.Fd fd)
+  where
+    all_flags  = unionFlags $ optional_flags ++ [open_mode] ++ creat
+
+
+    (creat, mode_w) = case maybe_mode of
+                        Nothing -> ([],0)
+                        Just x  -> ([oCreat], x)
+
+    open_mode = case how of
+                   Posix.ReadOnly  -> oRdonly
+                   Posix.WriteOnly -> oWronly
+                   Posix.ReadWrite -> oRdwr
+
+
+-- |Open and optionally create this file. See 'System.Posix.Files'
+-- for information on how to use the 'FileMode' type.
+--
+-- Note that passing @Just x@ as the 4th argument triggers the
+-- `oCreat` status flag, which must be set when you pass in `oExcl`
+-- to the status flags. Also see the manpage for @open(2)@.
+openFd :: RawFilePath
+       -> Posix.OpenMode
+       -> [Flags]               -- ^ status flags of @open(2)@
+       -> Maybe Posix.FileMode  -- ^ @Just x@ => creates the file with the given modes, Nothing => the file must exist.
+       -> IO Posix.Fd
+openFd name how optional_flags maybe_mode =
+   withFilePath name $ \str ->
+     throwErrnoPathIfMinus1Retry "openFd" name $
+       open_ str how optional_flags maybe_mode
+

src/System/Posix/FilePath.hs

@@ -0,0 +1,823 @@
+-- |
+-- Module      :  System.Posix.FilePath
+-- Copyright   :  © 2016 Julian Ospald
+-- License     :  BSD3
+--
+-- Maintainer  :  Julian Ospald <hasufell@posteo.de>
+-- Stability   :  experimental
+-- Portability :  portable
+--
+-- The equivalent of "System.FilePath" on raw (byte string) file paths.
+--
+-- Not all functions of "System.FilePath" are implemented yet. Feel free to contribute!
+
+
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TupleSections #-}
+
+{-# OPTIONS_GHC -Wall #-}
+
+
+module System.Posix.FilePath (
+
+  -- * Separator predicates
+  pathSeparator
+, isPathSeparator
+, searchPathSeparator
+, isSearchPathSeparator
+, extSeparator
+, isExtSeparator
+
+  -- * $PATH methods
+, splitSearchPath
+, getSearchPath
+
+  -- * Extension functions
+, splitExtension
+, takeExtension
+, replaceExtension
+, dropExtension
+, addExtension
+, hasExtension
+, (<.>)
+, splitExtensions
+, dropExtensions
+, takeExtensions
+, stripExtension
+
+  -- * Filename\/directory functions
+, splitFileName
+, takeFileName
+, replaceFileName
+, dropFileName
+, takeBaseName
+, replaceBaseName
+, takeDirectory
+, replaceDirectory
+, combine
+, (</>)
+, splitPath
+, joinPath
+, splitDirectories
+
+  -- * Trailing slash functions
+, hasTrailingPathSeparator
+, addTrailingPathSeparator
+, dropTrailingPathSeparator
+
+  -- * File name manipulations
+, normalise
+, makeRelative
+, equalFilePath
+, isRelative
+, isAbsolute
+, isValid
+, makeValid
+, isFileName
+, hasParentDir
+, hiddenFile
+
+, module System.Posix.ByteString.FilePath
+) where
+
+import           Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import Data.String (fromString)
+import           System.Posix.ByteString.FilePath
+import qualified System.Posix.Env.ByteString as PE
+
+import           Data.Maybe (isJust)
+import           Data.Word8
+#if !MIN_VERSION_bytestring(0,10,8)
+import qualified Data.List as L
+#endif
+import           Control.Arrow (second)
+
+-- $setup
+-- >>> import Data.Char
+-- >>> import Data.Maybe
+-- >>> import Test.QuickCheck
+-- >>> import Control.Applicative
+-- >>> import qualified Data.ByteString as BS
+-- >>> instance Arbitrary ByteString where arbitrary = BS.pack <$> arbitrary
+-- >>> instance CoArbitrary ByteString where coarbitrary = coarbitrary . BS.unpack
+--
+-- >>> let _chr :: Word8 -> Char; _chr = chr . fromIntegral
+
+
+
+------------------------
+-- Separator predicates
+
+
+-- | Path separator character
+pathSeparator :: Word8
+pathSeparator = _slash
+
+
+-- | Check if a character is the path separator
+--
+-- prop> \n ->  (_chr n == '/') == isPathSeparator n
+isPathSeparator :: Word8 -> Bool
+isPathSeparator = (== pathSeparator)
+
+
+-- | Search path separator
+searchPathSeparator :: Word8
+searchPathSeparator = _colon
+
+
+-- | Check if a character is the search path separator
+--
+-- prop> \n -> (_chr n == ':') == isSearchPathSeparator n
+isSearchPathSeparator :: Word8 -> Bool
+isSearchPathSeparator = (== searchPathSeparator)
+
+
+-- | File extension separator
+extSeparator :: Word8
+extSeparator = _period
+
+
+-- | Check if a character is the file extension separator
+--
+-- prop> \n -> (_chr n == '.') == isExtSeparator n
+isExtSeparator :: Word8 -> Bool
+isExtSeparator = (== extSeparator)
+
+
+
+------------------------
+-- $PATH methods
+
+
+-- | Take a ByteString, split it on the 'searchPathSeparator'.
+-- Blank items are converted to @.@.
+--
+-- Follows the recommendations in
+-- <http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html>
+--
+-- >>> splitSearchPath "File1:File2:File3"
+-- ["File1","File2","File3"]
+-- >>> splitSearchPath "File1::File2:File3"
+-- ["File1",".","File2","File3"]
+-- >>> splitSearchPath ""
+-- ["."]
+splitSearchPath :: ByteString -> [RawFilePath]
+splitSearchPath = f
+  where
+    f bs = let (pre, post) = BS.break isSearchPathSeparator bs
+           in if BS.null post
+                 then g pre
+                 else g pre ++ f (BS.tail post)
+    g x
+      | BS.null x = [BS.singleton _period]
+      | otherwise = [x]
+
+
+-- | Get a list of 'RawFilePath's in the $PATH variable.
+getSearchPath :: IO [RawFilePath]
+getSearchPath = fmap (maybe [] splitSearchPath) (PE.getEnv $ fromString "PATH")
+
+
+
+------------------------
+-- Extension functions
+
+-- | Split a 'RawFilePath' into a path+filename and extension
+--
+-- >>> splitExtension "file.exe"
+-- ("file",".exe")
+-- >>> splitExtension "file"
+-- ("file","")
+-- >>> splitExtension "/path/file.tar.gz"
+-- ("/path/file.tar",".gz")
+--
+-- prop> \path -> uncurry (BS.append) (splitExtension path) == path
+splitExtension :: RawFilePath -> (RawFilePath, ByteString)
+splitExtension x = if BS.null basename
+    then (x,BS.empty)
+    else (BS.append path (BS.init basename),BS.cons extSeparator fileExt)
+  where
+    (path,file) = splitFileNameRaw x
+    (basename,fileExt) = BS.breakEnd isExtSeparator file
+
+
+-- | Get the final extension from a 'RawFilePath'
+--
+-- >>> takeExtension "file.exe"
+-- ".exe"
+-- >>> takeExtension "file"
+-- ""
+-- >>> takeExtension "/path/file.tar.gz"
+-- ".gz"
+takeExtension :: RawFilePath -> ByteString
+takeExtension = snd . splitExtension
+
+
+-- | Change a file's extension
+--
+-- prop> \path -> let ext = takeExtension path in replaceExtension path ext == path
+replaceExtension :: RawFilePath -> ByteString -> RawFilePath
+replaceExtension path ext = dropExtension path <.> ext
+
+
+-- | Drop the final extension from a 'RawFilePath'
+--
+-- >>> dropExtension "file.exe"
+-- "file"
+-- >>> dropExtension "file"
+-- "file"
+-- >>> dropExtension "/path/file.tar.gz"
+-- "/path/file.tar"
+dropExtension :: RawFilePath -> RawFilePath
+dropExtension = fst . splitExtension
+
+
+-- | Add an extension to a 'RawFilePath'
+--
+-- >>> addExtension "file" ".exe"
+-- "file.exe"
+-- >>> addExtension "file.tar" ".gz"
+-- "file.tar.gz"
+-- >>> addExtension "/path/" ".ext"
+-- "/path/.ext"
+addExtension :: RawFilePath -> ByteString -> RawFilePath
+addExtension file ext
+    | BS.null ext = file
+    | isExtSeparator (BS.head ext) = BS.append file ext
+    | otherwise = BS.intercalate (BS.singleton extSeparator) [file, ext]
+
+
+-- | Check if a 'RawFilePath' has an extension
+--
+-- >>> hasExtension "file"
+-- False
+-- >>> hasExtension "file.tar"
+-- True
+-- >>> hasExtension "/path.part1/"
+-- False
+hasExtension :: RawFilePath -> Bool
+hasExtension = isJust . BS.elemIndex extSeparator . takeFileName
+
+
+-- | Operator version of 'addExtension'
+(<.>) :: RawFilePath -> ByteString -> RawFilePath
+(<.>) = addExtension
+
+
+-- | Split a 'RawFilePath' on the first extension.
+--
+-- >>> splitExtensions "/path/file.tar.gz"
+-- ("/path/file",".tar.gz")
+--
+-- prop> \path -> uncurry addExtension (splitExtensions path) == path
+splitExtensions :: RawFilePath -> (RawFilePath, ByteString)
+splitExtensions x = if BS.null basename
+    then (path,fileExt)
+    else (BS.append path basename,fileExt)
+  where
+    (path,file) = splitFileNameRaw x
+    (basename,fileExt) = BS.break isExtSeparator file
+
+
+-- | Remove all extensions from a 'RawFilePath'
+--
+-- >>> dropExtensions "/path/file.tar.gz"
+-- "/path/file"
+dropExtensions :: RawFilePath -> RawFilePath
+dropExtensions = fst . splitExtensions
+
+
+-- | Take all extensions from a 'RawFilePath'
+--
+-- >>> takeExtensions "/path/file.tar.gz"
+-- ".tar.gz"
+takeExtensions :: RawFilePath -> ByteString
+takeExtensions = snd . splitExtensions
+
+
+-- | Drop the given extension from a FilePath, and the @\".\"@ preceding it.
+-- Returns 'Nothing' if the FilePath does not have the given extension, or
+-- 'Just' and the part before the extension if it does.
+--
+-- This function can be more predictable than 'dropExtensions',
+-- especially if the filename might itself contain @.@ characters.
+--
+-- >>> stripExtension "hs.o" "foo.x.hs.o"
+-- Just "foo.x"
+-- >>> stripExtension "hi.o" "foo.x.hs.o"
+-- Nothing
+-- >>> stripExtension ".c.d" "a.b.c.d"
+-- Just "a.b"
+-- >>> stripExtension ".c.d" "a.b..c.d"
+-- Just "a.b."
+-- >>> stripExtension "baz"  "foo.bar"
+-- Nothing
+-- >>> stripExtension "bar"  "foobar"
+-- Nothing
+--
+-- prop> \path -> stripExtension "" path == Just path
+-- prop> \path -> dropExtension path  == fromJust (stripExtension (takeExtension path) path)
+-- prop> \path -> dropExtensions path == fromJust (stripExtension (takeExtensions path) path)
+stripExtension :: ByteString -> RawFilePath -> Maybe RawFilePath
+stripExtension bs path
+  | BS.null bs = Just path
+  | otherwise  = stripSuffix' dotExt path
+  where
+    dotExt = if isExtSeparator $ BS.head bs
+                then bs
+                else extSeparator `BS.cons` bs
+#if MIN_VERSION_bytestring(0,10,8)
+    stripSuffix' = BS.stripSuffix
+#else
+    stripSuffix' xs ys = fmap (BS.pack . reverse) $ L.stripPrefix (reverse $ BS.unpack xs) (reverse $ BS.unpack ys)
+#endif
+
+
+------------------------
+-- Filename/directory functions
+
+
+-- | Split a 'RawFilePath' into (path,file).  'combine' is the inverse
+--
+-- >>> splitFileName "path/file.txt"
+-- ("path/","file.txt")
+-- >>> splitFileName "path/"
+-- ("path/","")
+-- >>> splitFileName "file.txt"
+-- ("./","file.txt")
+--
+-- prop> \path -> uncurry combine (splitFileName path) == path || fst (splitFileName path) == "./"
+splitFileName :: RawFilePath -> (RawFilePath, RawFilePath)
+splitFileName x = if BS.null path
+    then (dotSlash, file)
+    else (path,file)
+  where
+    (path,file) = splitFileNameRaw x
+    dotSlash = _period `BS.cons` (BS.singleton pathSeparator)
+
+
+-- | Get the file name
+--
+-- >>> takeFileName "path/file.txt"
+-- "file.txt"
+-- >>> takeFileName "path/"
+-- ""
+takeFileName :: RawFilePath -> RawFilePath
+takeFileName = snd . splitFileName
+
+
+-- | Change the file name
+--
+-- prop> \path -> replaceFileName path (takeFileName path) == path
+replaceFileName :: RawFilePath -> ByteString -> RawFilePath
+replaceFileName x y = fst (splitFileNameRaw x) </> y
+
+
+-- | Drop the file name
+--
+-- >>> dropFileName "path/file.txt"
+-- "path/"
+-- >>> dropFileName "file.txt"
+-- "./"
+dropFileName :: RawFilePath -> RawFilePath
+dropFileName = fst . splitFileName
+
+
+-- | Get the file name, without a trailing extension
+--
+-- >>> takeBaseName "path/file.tar.gz"
+-- "file.tar"
+-- >>> takeBaseName ""
+-- ""
+takeBaseName :: RawFilePath -> ByteString
+takeBaseName = dropExtension . takeFileName
+
+
+-- | Change the base name
+--
+-- >>> replaceBaseName "path/file.tar.gz" "bob"
+-- "path/bob.gz"
+--
+-- prop> \path -> replaceBaseName path (takeBaseName path) == path
+replaceBaseName :: RawFilePath -> ByteString -> RawFilePath
+replaceBaseName path name = combineRaw dir (name <.> ext)
+  where
+    (dir,file) = splitFileNameRaw path
+    ext = takeExtension file
+
+
+-- | Get the directory, moving up one level if it's already a directory
+--
+-- >>> takeDirectory "path/file.txt"
+-- "path"
+-- >>> takeDirectory "file"
+-- "."
+-- >>> takeDirectory "/path/to/"
+-- "/path/to"
+-- >>> takeDirectory "/path/to"
+-- "/path"
+takeDirectory :: RawFilePath -> RawFilePath
+takeDirectory x = case () of
+    () | x == BS.singleton pathSeparator -> x
+       | BS.null res && not (BS.null file) -> file
+       | otherwise -> res
+  where
+    res = fst $ BS.spanEnd isPathSeparator file
+    file = dropFileName x
+
+
+-- | Change the directory component of a 'RawFilePath'
+--
+-- prop> \path -> replaceDirectory path (takeDirectory path) `equalFilePath` path || takeDirectory path == "."
+replaceDirectory :: RawFilePath -> ByteString -> RawFilePath
+replaceDirectory file dir = combineRaw dir (takeFileName file)
+
+
+-- | Join two paths together
+--
+-- >>> combine "/" "file"
+-- "/file"
+-- >>> combine "/path/to" "file"
+-- "/path/to/file"
+-- >>> combine "file" "/absolute/path"
+-- "/absolute/path"
+combine :: RawFilePath -> RawFilePath -> RawFilePath
+combine a b | not (BS.null b) && isPathSeparator (BS.head b) = b
+            | otherwise = combineRaw a b
+
+
+-- | Operator version of combine
+(</>) :: RawFilePath -> RawFilePath -> RawFilePath
+(</>) = combine
+
+-- | Split a path into a list of components:
+--
+-- >>> splitPath "/path/to/file.txt"
+-- ["/","path/","to/","file.txt"]
+--
+-- prop> \path -> BS.concat (splitPath path) == path
+splitPath :: RawFilePath -> [RawFilePath]
+splitPath = splitter
+  where
+    splitter x
+      | BS.null x = []
+      | otherwise = case BS.elemIndex pathSeparator x of
+            Nothing -> [x]
+            Just ix -> case BS.findIndex (not . isPathSeparator) $ BS.drop (ix+1) x of
+                          Nothing -> [x]
+                          Just runlen -> uncurry (:) . second splitter $ BS.splitAt (ix+1+runlen) x
+
+
+-- | Join a split path back together
+--
+-- prop> \path -> joinPath (splitPath path) == path
+--
+-- >>> joinPath ["path","to","file.txt"]
+-- "path/to/file.txt"
+joinPath :: [RawFilePath] -> RawFilePath
+joinPath = foldr (</>) BS.empty
+
+
+-- | Like 'splitPath', but without trailing slashes
+--
+-- >>> splitDirectories "/path/to/file.txt"
+-- ["/","path","to","file.txt"]
+-- >>> splitDirectories ""
+-- []
+splitDirectories :: RawFilePath -> [RawFilePath]
+splitDirectories x
+    | BS.null x = []
+    | isPathSeparator (BS.head x) = let (root,rest) = BS.splitAt 1 x
+                                    in root : splitter rest
+    | otherwise = splitter x
+  where
+    splitter = filter (not . BS.null) . BS.split pathSeparator
+
+
+
+------------------------
+-- Trailing slash functions
+
+-- | Check if the last character of a 'RawFilePath' is '/'.
+--
+-- >>> hasTrailingPathSeparator "/path/"
+-- True
+-- >>> hasTrailingPathSeparator "/"
+-- True
+-- >>> hasTrailingPathSeparator "/path"
+-- False
+hasTrailingPathSeparator :: RawFilePath -> Bool
+hasTrailingPathSeparator x
+  | BS.null x = False
+  | otherwise = isPathSeparator $ BS.last x
+
+
+-- | Add a trailing path separator.
+--
+-- >>> addTrailingPathSeparator "/path"
+-- "/path/"
+-- >>> addTrailingPathSeparator "/path/"
+-- "/path/"
+-- >>> addTrailingPathSeparator "/"
+-- "/"
+addTrailingPathSeparator :: RawFilePath -> RawFilePath
+addTrailingPathSeparator x = if hasTrailingPathSeparator x
+    then x
+    else x `BS.snoc` pathSeparator
+
+
+-- | Remove a trailing path separator
+--
+-- >>> dropTrailingPathSeparator "/path/"
+-- "/path"
+-- >>> dropTrailingPathSeparator "/path////"
+-- "/path"
+-- >>> dropTrailingPathSeparator "/"
+-- "/"
+-- >>> dropTrailingPathSeparator "//"
+-- "/"
+dropTrailingPathSeparator :: RawFilePath -> RawFilePath
+dropTrailingPathSeparator x
+  | x == BS.singleton pathSeparator = x
+  | otherwise = if hasTrailingPathSeparator x
+                  then dropTrailingPathSeparator $ BS.init x
+                  else x
+
+
+
+------------------------
+-- File name manipulations
+
+
+-- |Normalise a file.
+--
+-- >>> normalise "/file/\\test////"
+-- "/file/\\test/"
+-- >>> normalise "/file/./test"
+-- "/file/test"
+-- >>> normalise "/test/file/../bob/fred/"
+-- "/test/file/../bob/fred/"
+-- >>> normalise "../bob/fred/"
+-- "../bob/fred/"
+-- >>> normalise "./bob/fred/"
+-- "bob/fred/"
+-- >>> normalise "./bob////.fred/./...///./..///#."
+-- "bob/.fred/.../../#."
+-- >>> normalise "."
+-- "."
+-- >>> normalise "./"
+-- "./"
+-- >>> normalise "./."
+-- "./"
+-- >>> normalise "/./"
+-- "/"
+-- >>> normalise "/"
+-- "/"
+-- >>> normalise "bob/fred/."
+-- "bob/fred/"
+-- >>> normalise "//home"
+-- "/home"
+normalise :: RawFilePath -> RawFilePath
+normalise filepath =
+  result `BS.append`
+  (if addPathSeparator
+       then BS.singleton pathSeparator
+       else BS.empty)
+  where
+    result = let n = f filepath
+             in if BS.null n
+                then BS.singleton _period
+                else n
+    addPathSeparator = isDirPath filepath &&
+      not (hasTrailingPathSeparator result)
+    isDirPath xs = hasTrailingPathSeparator xs
+        || not (BS.null xs) && BS.last xs == _period
+           && hasTrailingPathSeparator (BS.init xs)
+    f = joinPath . dropDots . propSep . splitDirectories
+    propSep :: [ByteString] -> [ByteString]
+    propSep (x:xs)
+      | BS.all (== pathSeparator) x = BS.singleton pathSeparator : xs
+      | otherwise                   = x : xs
+    propSep [] = []
+    dropDots :: [ByteString] -> [ByteString]
+    dropDots = filter (BS.singleton _period /=)
+
+
+
+-- | Contract a filename, based on a relative path. Note that the resulting
+-- path will never introduce @..@ paths, as the presence of symlinks
+-- means @..\/b@ may not reach @a\/b@ if it starts from @a\/c@. For a
+-- worked example see
+-- <http://neilmitchell.blogspot.co.uk/2015/10/filepaths-are-subtle-symlinks-are-hard.html this blog post>.
+--
+-- >>> makeRelative "/directory" "/directory/file.ext"
+-- "file.ext"
+-- >>> makeRelative "/Home" "/home/bob"
+-- "/home/bob"
+-- >>> makeRelative "/home/" "/home/bob/foo/bar"
+-- "bob/foo/bar"
+-- >>> makeRelative "/fred" "bob"
+-- "bob"
+-- >>> makeRelative "/file/test" "/file/test/fred"
+-- "fred"
+-- >>> makeRelative "/file/test" "/file/test/fred/"
+-- "fred/"
+-- >>> makeRelative "some/path" "some/path/a/b/c"
+-- "a/b/c"
+--
+-- prop> \p -> makeRelative p p == "."
+-- prop> \p -> makeRelative (takeDirectory p) p `equalFilePath` takeFileName p
+-- prop \x y -> equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y </> makeRelative y x) x
+makeRelative :: RawFilePath -> RawFilePath -> RawFilePath
+makeRelative root path
+  | equalFilePath root path = BS.singleton _period
+  | takeAbs root /= takeAbs path = path
+  | otherwise = f (dropAbs root) (dropAbs path)
+  where
+    f x y
+      | BS.null x = BS.dropWhile isPathSeparator y
+      | otherwise = let (x1,x2) = g x
+                        (y1,y2) = g y
+                    in if equalFilePath x1 y1 then f x2 y2 else path
+    g x = (BS.dropWhile isPathSeparator a, BS.dropWhile isPathSeparator b)
+      where (a, b) = BS.break isPathSeparator $ BS.dropWhile isPathSeparator x
+    dropAbs x = snd $ BS.span (== _slash) x
+    takeAbs x = fst $ BS.span (== _slash) x
+
+
+-- |Equality of two filepaths. The filepaths are normalised
+-- and trailing path separators are dropped.
+--
+-- >>> equalFilePath "foo" "foo"
+-- True
+-- >>> equalFilePath "foo" "foo/"
+-- True
+-- >>> equalFilePath "foo" "./foo"
+-- True
+-- >>> equalFilePath "" ""
+-- True
+-- >>> equalFilePath "foo" "/foo"
+-- False
+-- >>> equalFilePath "foo" "FOO"
+-- False
+-- >>> equalFilePath "foo" "../foo"
+-- False
+--
+-- prop> \p -> equalFilePath p p
+equalFilePath :: RawFilePath -> RawFilePath -> Bool
+equalFilePath p1 p2 = f p1 == f p2
+  where
+    f x = dropTrailingPathSeparator $ normalise x
+
+
+-- | Check if a path is relative
+--
+-- prop> \path -> isRelative path /= isAbsolute path
+isRelative :: RawFilePath -> Bool
+isRelative = not . isAbsolute
+
+
+-- | Check if a path is absolute
+--
+-- >>> isAbsolute "/path"
+-- True
+-- >>> isAbsolute "path"
+-- False
+-- >>> isAbsolute ""
+-- False
+isAbsolute :: RawFilePath -> Bool
+isAbsolute x
+    | BS.length x > 0 = isPathSeparator (BS.head x)
+    | otherwise = False
+
+
+-- | Is a FilePath valid, i.e. could you create a file like it?
+--
+-- >>> isValid ""
+-- False
+-- >>> isValid "\0"
+-- False
+-- >>> isValid "/random_ path:*"
+-- True
+isValid :: RawFilePath -> Bool
+isValid filepath
+  | BS.null filepath        = False
+  | _nul `BS.elem` filepath = False
+  | otherwise               = True
+
+
+-- | Take a FilePath and make it valid; does not change already valid FilePaths.
+--
+-- >>> makeValid ""
+-- "_"
+-- >>> makeValid "file\0name"
+-- "file_name"
+--
+-- prop> \p -> if isValid p then makeValid p == p else makeValid p /= p
+-- prop> \p -> isValid (makeValid p)
+makeValid :: RawFilePath -> RawFilePath
+makeValid path
+  | BS.null path = BS.singleton _underscore
+  | otherwise    = BS.map (\x -> if x == _nul then _underscore else x) path
+
+
+-- | Is the given path a valid filename? This includes
+-- "." and "..".
+--
+-- >>> isFileName "lal"
+-- True
+-- >>> isFileName "."
+-- True
+-- >>> isFileName ".."
+-- True
+-- >>> isFileName ""
+-- False
+-- >>> isFileName "\0"
+-- False
+-- >>> isFileName "/random_ path:*"
+-- False
+isFileName :: RawFilePath -> Bool
+isFileName filepath =
+  not (BS.singleton pathSeparator `BS.isInfixOf` filepath) &&
+  not (BS.null filepath) &&
+  not (_nul `BS.elem` filepath)
+
+
+-- | Check if the filepath has any parent directories in it.
+--
+-- >>> hasParentDir "/.."
+-- True
+-- >>> hasParentDir "foo/bar/.."
+-- True
+-- >>> hasParentDir "foo/../bar/."
+-- True
+-- >>> hasParentDir "foo/bar"
+-- False
+-- >>> hasParentDir "foo"
+-- False
+-- >>> hasParentDir ""
+-- False
+-- >>> hasParentDir ".."
+-- False
+hasParentDir :: RawFilePath -> Bool
+hasParentDir filepath =
+    (pathSeparator `BS.cons` pathDoubleDot)
+     `BS.isSuffixOf` filepath
+   ||
+    (BS.singleton pathSeparator
+        `BS.append` pathDoubleDot
+        `BS.append` BS.singleton pathSeparator)
+     `BS.isInfixOf`  filepath
+   ||
+    (pathDoubleDot `BS.append` BS.singleton pathSeparator)
+      `BS.isPrefixOf` filepath
+  where
+    pathDoubleDot = BS.pack [_period, _period]
+
+
+-- | Whether the file is a hidden file.
+--
+-- >>> hiddenFile ".foo"
+-- True
+-- >>> hiddenFile "..foo.bar"
+-- True
+-- >>> hiddenFile "some/path/.bar"
+-- True
+-- >>> hiddenFile "..."
+-- True
+-- >>> hiddenFile "dod.bar"
+-- False
+-- >>> hiddenFile "."
+-- False
+-- >>> hiddenFile ".."
+-- False
+-- >>> hiddenFile ""
+-- False
+hiddenFile :: RawFilePath -> Bool
+hiddenFile fp
+  | fn == BS.pack [_period, _period] = False
+  | fn == BS.pack [_period]          = False
+  | otherwise                        = BS.pack [extSeparator]
+                                         `BS.isPrefixOf` fn
+  where
+    fn = takeFileName fp
+
+
+
+------------------------
+-- internal stuff
+
+-- Just split the input FileName without adding/normalizing or changing
+-- anything.
+splitFileNameRaw :: RawFilePath -> (RawFilePath, RawFilePath)
+splitFileNameRaw = BS.breakEnd isPathSeparator
+
+-- | Combine two paths, assuming rhs is NOT absolute.
+combineRaw :: RawFilePath -> RawFilePath -> RawFilePath
+combineRaw a b | BS.null a = b
+                  | BS.null b = a
+                  | isPathSeparator (BS.last a) = BS.append a b
+                  | otherwise = BS.intercalate (BS.singleton pathSeparator) [a, b]
+

test/HPath/IO/CanonicalizePathSpec.hs

@@ -0,0 +1,78 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CanonicalizePathSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CanonicalizePathSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createSymlink' "dirSym" "dir/"
+  createSymlink' "brokenSym" "nothing"
+  createSymlink' "fileSym" "file"
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "file"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "brokenSym"
+  deleteFile' "fileSym"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.canonicalizePath" $ do
+
+    -- successes --
+    it "canonicalizePath, all fine" $ do
+      path <- withTmpDir "file" return
+      canonicalizePath' "file"
+        `shouldReturn` path
+
+    it "canonicalizePath, all fine" $ do
+      path <- withTmpDir "dir" return
+      canonicalizePath' "dir"
+        `shouldReturn` path
+
+    it "canonicalizePath, all fine" $ do
+      path <- withTmpDir "file" return
+      canonicalizePath' "fileSym"
+        `shouldReturn` path
+
+    it "canonicalizePath, all fine" $ do
+      path <- withTmpDir "dir" return
+      canonicalizePath' "dirSym"
+        `shouldReturn` path
+
+
+    -- posix failures --
+    it "canonicalizePath, broken symlink" $
+      canonicalizePath' "brokenSym"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "canonicalizePath, file does not exist" $
+      canonicalizePath' "nothingBlah"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+

test/HPath/IO/CopyDirRecursiveCollectFailuresSpec.hs

@@ -0,0 +1,245 @@
+{-# 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 (\e -> ioeGetErrorType e == InappropriateType) ex &&
+          any (\e -> ioeGetErrorType e == PermissionDenied) 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 [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 [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 [e]) -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive (Strict, CollectFailures), wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [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
+
+

test/HPath/IO/CopyDirRecursiveOverwriteSpec.hs

@@ -0,0 +1,202 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.CopyDirRecursiveOverwriteSpec where
+
+
+import Test.Hspec
+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 Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveOverwriteSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createRegularFile' "wrongInput"
+  createSymlink' "wrongInputSymL" "inputDir/"
+  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' "alreadyExistsD"
+  createDir' "alreadyExistsD/bar"
+  createDir' "alreadyExistsD/foo"
+  createRegularFile' "alreadyExistsD/foo/inputFile1"
+  createRegularFile' "alreadyExistsD/inputFile2"
+  createRegularFile' "alreadyExistsD/bar/inputFile3"
+  writeFile' "alreadyExistsD/foo/inputFile1" "DAAsada"
+  writeFile' "alreadyExistsD/inputFile2" "ahfaagaga"
+  writeFile' "alreadyExistsD/bar/inputFile3"
+    "f3223sasdasdaasdasdasasd4"
+
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "alreadyExists"
+  deleteFile' "wrongInput"
+  deleteFile' "wrongInputSymL"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+  deleteFile' "inputDir/foo/inputFile1"
+  deleteFile' "inputDir/inputFile2"
+  deleteFile' "inputDir/bar/inputFile3"
+  deleteDir' "inputDir/foo"
+  deleteDir' "inputDir/bar"
+  deleteDir' "inputDir"
+  deleteFile' "alreadyExistsD/foo/inputFile1"
+  deleteFile' "alreadyExistsD/inputFile2"
+  deleteFile' "alreadyExistsD/bar/inputFile3"
+  deleteDir' "alreadyExistsD/foo"
+  deleteDir' "alreadyExistsD/bar"
+  deleteDir' "alreadyExistsD"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyDirRecursive" $ do
+
+    -- successes --
+    it "copyDirRecursive (Overwrite, FailEarly), all fine" $ do
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
+      removeDirIfExists "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")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+    it "copyDirRecursive (Overwrite, FailEarly), destination dir already exists" $ do
+      tmpDir' <- getRawTmpDir
+      (system $ "diff -r --no-dereference "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD")
+        `shouldReturn` (ExitFailure 1)
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Overwrite
+                        FailEarly
+      (system $ "diff -r --no-dereference "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+
+    -- posix failures --
+    it "copyDirRecursive, source directory does not exist" $
+      copyDirRecursive' "doesNotExist"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyDirRecursive, no write permission on output dir" $
+      copyDirRecursive' "inputDir"
+                        "noWritePerm/foo"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive, cannot open output dir" $
+      copyDirRecursive' "inputDir"
+                        "noPerms/foo"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive, cannot open source dir" $
+      copyDirRecursive' "noPerms/inputDir"
+                        "foo"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive, destination already exists and is a file" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExists"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive, wrong input (regular file)" $
+      copyDirRecursive' "wrongInput"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive, wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    -- custom failures
+    it "copyDirRecursive (Overwrite, FailEarly), destination in source" $
+      copyDirRecursive' "inputDir"
+                        "inputDir/foo"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        isDestinationInSource
+
+    it "copyDirRecursive (Overwrite, FailEarly), destination and source same directory" $
+      copyDirRecursive' "inputDir"
+                        "inputDir"
+                        Overwrite
+                        FailEarly
+        `shouldThrow`
+        isSameFile

test/HPath/IO/CopyDirRecursiveSpec.hs

@@ -0,0 +1,180 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.CopyDirRecursiveSpec where
+
+
+import Test.Hspec
+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 Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveSpec"
+  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"
+
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  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, FailEarly), all fine" $ do
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Strict
+                        FailEarly
+      removeDirIfExists "outputDir"
+
+    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")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+    -- posix failures --
+    it "copyDirRecursive (Strict, FailEarly), source directory does not exist" $
+      copyDirRecursive' "doesNotExist"
+                        "outputDir"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyDirRecursive (Strict, FailEarly), no write permission on output dir" $
+      copyDirRecursive' "inputDir"
+                        "noWritePerm/foo"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive (Strict, FailEarly), cannot open output dir" $
+      copyDirRecursive' "inputDir"
+                        "noPerms/foo"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive (Strict, FailEarly), cannot open source dir" $
+      copyDirRecursive' "noPerms/inputDir"
+                        "foo"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive (Strict, FailEarly), destination dir already exists" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "copyDirRecursive (Strict, FailEarly), destination already exists and is a file" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExists"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "copyDirRecursive (Strict, FailEarly), wrong input (regular file)" $
+      copyDirRecursive' "wrongInput"
+                        "outputDir"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive (Strict, FailEarly), wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    -- custom failures
+    it "copyDirRecursive (Strict, FailEarly), destination in source" $
+      copyDirRecursive' "inputDir"
+                        "inputDir/foo"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        isDestinationInSource
+
+    it "copyDirRecursive (Strict, FailEarly), destination and source same directory" $
+      copyDirRecursive' "inputDir"
+                        "inputDir"
+                        Strict
+                        FailEarly
+        `shouldThrow`
+        isSameFile
+
+

test/HPath/IO/CopyFileOverwriteSpec.hs

@@ -0,0 +1,148 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CopyFileOverwriteSpec where
+
+
+import Test.Hspec
+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 Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileOverwriteSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "inputFile"
+  createRegularFile' "alreadyExists"
+  createSymlink' "inputFileSymL" "inputFile"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/inputFile"
+  createDir' "outputDirNoWrite"
+  createDir' "wrongInput"
+  noPerms "noPerms"
+  noWritableDirPerms "outputDirNoWrite"
+  writeFile' "inputFile" "Blahfaselgagaga"
+  writeFile' "alreadyExists" "dsaldsalkaklsdlkasksdadasl"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "outputDirNoWrite"
+  deleteFile' "noPerms/inputFile"
+  deleteFile' "inputFile"
+  deleteFile' "alreadyExists"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "outputDirNoWrite"
+  deleteDir' "wrongInput"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyFile" $ do
+
+    -- successes --
+    it "copyFile (Overwrite), everything clear" $ do
+      copyFile' "inputFile"
+                "outputFile"
+                Overwrite
+      removeFileIfExists "outputFile"
+
+    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" Strict
+      removeFileIfExists "alreadyExists.bak"
+
+    it "copyFile (Overwrite), and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "inputFile"
+                "outputFile"
+                Overwrite
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
+        `shouldReturn` ExitSuccess
+      removeFileIfExists "outputFile"
+
+
+    -- posix failures --
+    it "copyFile (Overwrite), input file does not exist" $
+      copyFile' "noSuchFile"
+                "outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyFile (Overwrite), no permission to write to output directory" $
+      copyFile' "inputFile"
+                "outputDirNoWrite/outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Overwrite), cannot open output directory" $
+      copyFile' "inputFile"
+                "noPerms/outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Overwrite), cannot open source directory" $
+      copyFile' "noPerms/inputFile"
+                "outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Overwrite), wrong input type (symlink)" $
+      copyFile' "inputFileSymL"
+                "outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "copyFile (Overwrite), wrong input type (directory)" $
+      copyFile' "wrongInput"
+                "outputFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "copyFile (Overwrite), output file already exists and is a dir" $
+      copyFile' "inputFile"
+                "alreadyExistsD"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    -- custom failures --
+    it "copyFile (Overwrite), output and input are same file" $
+      copyFile' "inputFile"
+                "inputFile"
+                Overwrite
+        `shouldThrow` isSameFile

test/HPath/IO/CopyFileSpec.hs

@@ -0,0 +1,143 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module HPath.IO.CopyFileSpec where
+
+
+import Test.Hspec
+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 Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "inputFile"
+  createRegularFile' "alreadyExists"
+  createSymlink' "inputFileSymL" "inputFile"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/inputFile"
+  createDir' "outputDirNoWrite"
+  createDir' "wrongInput"
+  noPerms "noPerms"
+  noWritableDirPerms "outputDirNoWrite"
+  writeFile' "inputFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "outputDirNoWrite"
+  deleteFile' "noPerms/inputFile"
+  deleteFile' "inputFile"
+  deleteFile' "alreadyExists"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "outputDirNoWrite"
+  deleteDir' "wrongInput"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.copyFile" $ do
+
+    -- successes --
+    it "copyFile (Strict), everything clear" $ do
+      copyFile' "inputFile"
+                "outputFile"
+                Strict
+      removeFileIfExists "outputFile"
+
+    it "copyFile (Strict), and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "inputFile"
+                "outputFile"
+                Strict
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
+        `shouldReturn` ExitSuccess
+      removeFileIfExists "outputFile"
+
+    -- posix failures --
+    it "copyFile (Strict), input file does not exist" $
+      copyFile' "noSuchFile"
+                "outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyFile (Strict), no permission to write to output directory" $
+      copyFile' "inputFile"
+                "outputDirNoWrite/outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Strict), cannot open output directory" $
+      copyFile' "inputFile"
+                "noPerms/outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Strict), cannot open source directory" $
+      copyFile' "noPerms/inputFile"
+                "outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyFile (Strict), wrong input type (symlink)" $
+      copyFile' "inputFileSymL"
+                "outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "copyFile (Strict), wrong input type (directory)" $
+      copyFile' "wrongInput"
+                "outputFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "copyFile (Strict), output file already exists" $
+      copyFile' "inputFile"
+                "alreadyExists"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "copyFile (Strict), output file already exists and is a dir" $
+      copyFile' "inputFile"
+                "alreadyExistsD"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    -- custom failures --
+    it "copyFile (Strict), output and input are same file" $
+      copyFile' "inputFile"
+                "inputFile"
+                Strict
+        `shouldThrow`
+        isSameFile

test/HPath/IO/CreateDirSpec.hs

@@ -0,0 +1,67 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CreateDirSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createDir' "alreadyExists"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
+
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteDir' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.createDir" $ do
+
+    -- successes --
+    it "createDir, all fine" $ do
+      createDir' "newDir"
+      removeDirIfExists "newDir"
+
+    -- posix failures --
+    it "createDir, can't write to output directory" $
+      createDir' "noWritePerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createDir, can't open output directory" $
+      createDir' "noPerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createDir, destination directory already exists" $
+      createDir' "alreadyExists"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+

test/HPath/IO/CreateRegularFileSpec.hs

@@ -0,0 +1,65 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CreateRegularFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateRegularFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteFile' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.createRegularFile" $ do
+
+    -- successes --
+    it "createRegularFile, all fine" $ do
+      createRegularFile' "newDir"
+      removeFileIfExists "newDir"
+
+    -- posix failures --
+    it "createRegularFile, can't write to destination directory" $
+      createRegularFile' "noWritePerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createRegularFile, can't write to destination directory" $
+      createRegularFile' "noPerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createRegularFile, destination file already exists" $
+      createRegularFile' "alreadyExists"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+

test/HPath/IO/CreateSymlinkSpec.hs

@@ -0,0 +1,66 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.CreateSymlinkSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateSymlinkSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteFile' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.createSymlink" $ do
+
+    -- successes --
+    it "createSymlink, all fine" $ do
+      createSymlink' "newSymL" "alreadyExists/"
+      removeFileIfExists "newSymL"
+
+    -- posix failures --
+    it "createSymlink, can't write to destination directory" $
+      createSymlink' "noWritePerms/newDir" "lala"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createSymlink, can't write to destination directory" $
+      createSymlink' "noPerms/newDir" "lala"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createSymlink, destination file already exists" $
+      createSymlink' "alreadyExists" "lala"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+

test/HPath/IO/DeleteDirRecursiveSpec.hs

@@ -0,0 +1,116 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.DeleteDirRecursiveSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import System.Posix.Files.ByteString
+  (
+    getSymbolicLinkStatus
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirRecursiveSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createRegularFile' "dir/.keep"
+  createSymlink' "dirSym" "dir/"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/.keep"
+  createDir' "noWritable"
+  createRegularFile' "noWritable/.keep"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "file"
+  deleteFile' "dir/.keep"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "noPerms/.keep"
+  deleteDir' "noPerms"
+  deleteFile' "noWritable/.keep"
+  deleteDir' "noWritable"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.deleteDirRecursive" $ do
+
+    -- successes --
+    it "deleteDirRecursive, empty directory, all fine" $ do
+      createDir' "testDir"
+      deleteDirRecursive' "testDir"
+      getSymbolicLinkStatus "testDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "deleteDirRecursive, empty directory with null permissions, all fine" $ do
+      createDir' "noPerms/testDir"
+      noPerms "noPerms/testDir"
+      deleteDirRecursive' "noPerms/testDir"
+
+    it "deleteDirRecursive, non-empty directory, all fine" $ do
+      createDir' "nonEmpty"
+      createDir' "nonEmpty/dir1"
+      createDir' "nonEmpty/dir2"
+      createDir' "nonEmpty/dir2/dir3"
+      createRegularFile' "nonEmpty/file1"
+      createRegularFile' "nonEmpty/dir1/file2"
+      deleteDirRecursive' "nonEmpty"
+      getSymbolicLinkStatus "nonEmpty"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    -- posix failures --
+    it "deleteDirRecursive, can't open parent directory" $ do
+      createDir' "noPerms/foo"
+      noPerms "noPerms"
+      (deleteDirRecursive' "noPerms/foo")
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+      normalDirPerms "noPerms"
+      deleteDir' "noPerms/foo"
+
+    it "deleteDirRecursive, can't write to parent directory" $ do
+      createDir' "noWritable/foo"
+      noWritableDirPerms "noWritable"
+      (deleteDirRecursive' "noWritable/foo")
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+      normalDirPerms "noWritable"
+      deleteDir' "noWritable/foo"
+
+    it "deleteDirRecursive, wrong file type (symlink to directory)" $
+      deleteDirRecursive' "dirSym"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "deleteDirRecursive, wrong file type (regular file)" $
+      deleteDirRecursive' "file"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "deleteDirRecursive, directory does not exist" $
+      deleteDirRecursive' "doesNotExist"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+

test/HPath/IO/DeleteDirSpec.hs

@@ -0,0 +1,114 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.DeleteDirSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import System.Posix.Files.ByteString
+  (
+    getSymbolicLinkStatus
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createRegularFile' "dir/.keep"
+  createSymlink' "dirSym" "dir/"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/.keep"
+  createDir' "noWritable"
+  createRegularFile' "noWritable/.keep"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "file"
+  deleteFile' "dir/.keep"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "noPerms/.keep"
+  deleteDir' "noPerms"
+  deleteFile' "noWritable/.keep"
+  deleteDir' "noWritable"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.deleteDir" $ do
+
+    -- successes --
+    it "deleteDir, empty directory, all fine" $ do
+      createDir' "testDir"
+      deleteDir' "testDir"
+      getSymbolicLinkStatus "testDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "deleteDir, directory with null permissions, all fine" $ do
+      createDir' "noPerms/testDir"
+      noPerms "noPerms/testDir"
+      deleteDir' "noPerms/testDir"
+      getSymbolicLinkStatus "testDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    -- posix failures --
+    it "deleteDir, wrong file type (symlink to directory)" $
+      deleteDir' "dirSym"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "deleteDir, wrong file type (regular file)" $
+      deleteDir' "file"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "deleteDir, directory does not exist" $
+      deleteDir' "doesNotExist"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "deleteDir, directory not empty" $
+      deleteDir' "dir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == UnsatisfiedConstraints)
+
+    it "deleteDir, can't open parent directory" $ do
+      createDir' "noPerms/foo"
+      noPerms "noPerms"
+      (deleteDir' "noPerms/foo")
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+      normalDirPerms "noPerms"
+      deleteDir' "noPerms/foo"
+
+    it "deleteDir, can't write to parent directory, still fine" $ do
+      createDir' "noWritable/foo"
+      noWritableDirPerms "noWritable"
+      (deleteDir' "noWritable/foo")
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+      normalDirPerms "noWritable"
+      deleteDir' "noWritable/foo"
+
+
+

test/HPath/IO/DeleteFileSpec.hs

@@ -0,0 +1,84 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.DeleteFileSpec where
+
+
+import Test.Hspec
+import HPath.IO
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import System.Posix.Files.ByteString
+  (
+    getSymbolicLinkStatus
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteFileSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "foo"
+  createSymlink' "syml" "foo"
+  createDir' "dir"
+  createDir' "noPerms"
+  noPerms "noPerms"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "foo"
+  deleteFile' "syml"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.deleteFile" $ do
+
+    -- successes --
+    it "deleteFile, regular file, all fine" $ do
+      createRegularFile' "testFile"
+      deleteFile' "testFile"
+      getSymbolicLinkStatus "testFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "deleteFile, symlink, all fine" $ do
+      recreateSymlink' "syml"
+                       "testFile"
+                       Strict
+      deleteFile' "testFile"
+      getSymbolicLinkStatus "testFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    -- posix failures --
+    it "deleteFile, wrong file type (directory)" $
+      deleteFile' "dir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "deleteFile, file does not exist" $
+      deleteFile' "doesNotExist"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "deleteFile, can't read directory" $
+      deleteFile' "noPerms/blah"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+

test/HPath/IO/GetDirsFilesSpec.hs

@@ -0,0 +1,100 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.GetDirsFilesSpec where
+
+
+import Data.List
+  (
+    sort
+  )
+import qualified HPath as P
+import HPath.IO
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetDirsFilesSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "file"
+  createRegularFile' "Lala"
+  createRegularFile' ".hidden"
+  createSymlink' "syml" "Lala"
+  createDir' "dir"
+  createSymlink' "dirsym" "dir"
+  createDir' "noPerms"
+  noPerms "noPerms"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "file"
+  deleteFile' "Lala"
+  deleteFile' ".hidden"
+  deleteFile' "syml"
+  deleteDir' "dir"
+  deleteFile' "dirsym"
+  deleteDir' "noPerms"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.getDirsFiles" $ do
+
+    -- successes --
+    it "getDirsFiles, all fine" $
+      withRawTmpDir $ \p -> do
+      expectedFiles <- mapM P.parseRel [".hidden"
+                                       ,"Lala"
+                                       ,"dir"
+                                       ,"dirsym"
+                                       ,"file"
+                                       ,"noPerms"
+                                       ,"syml"]
+      (fmap sort $ getDirsFiles p)
+        `shouldReturn` fmap (p P.</>) expectedFiles
+
+    -- posix failures --
+    it "getDirsFiles, nonexistent directory" $
+      getDirsFiles' "nothingHere"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "getDirsFiles, wrong file type (file)" $
+      getDirsFiles' "file"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "getDirsFiles, wrong file type (symlink to file)" $
+      getDirsFiles' "syml"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "getDirsFiles, wrong file type (symlink to dir)" $
+      getDirsFiles' "dirsym"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "getDirsFiles, can't open directory" $
+      getDirsFiles' "noPerms"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+
+
+

test/HPath/IO/GetFileTypeSpec.hs

@@ -0,0 +1,88 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.GetFileTypeSpec where
+
+
+import HPath.IO
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetFileTypeSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "regularfile"
+  createSymlink' "symlink" "regularfile"
+  createSymlink' "brokenSymlink" "broken"
+  createDir' "directory"
+  createSymlink' "symlinkD" "directory"
+  createDir' "noPerms"
+  noPerms "noPerms"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "regularfile"
+  deleteFile' "symlink"
+  deleteFile' "brokenSymlink"
+  deleteDir' "directory"
+  deleteFile' "symlinkD"
+  deleteDir' "noPerms"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.getFileType" $ do
+
+    -- successes --
+    it "getFileType, regular file" $
+      getFileType' "regularfile"
+        `shouldReturn` RegularFile
+
+    it "getFileType, directory" $
+      getFileType' "directory"
+        `shouldReturn` Directory
+
+    it "getFileType, directory with null permissions" $
+      getFileType' "noPerms"
+        `shouldReturn` Directory
+
+    it "getFileType, symlink to file" $
+      getFileType' "symlink"
+        `shouldReturn` SymbolicLink
+
+    it "getFileType, symlink to directory" $
+      getFileType' "symlinkD"
+        `shouldReturn` SymbolicLink
+
+    it "getFileType, broken symlink" $
+      getFileType' "brokenSymlink"
+        `shouldReturn` SymbolicLink
+
+    -- posix failures --
+    it "getFileType, file does not exist" $
+      getFileType' "nothingHere"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "getFileType, can't open directory" $
+      getFileType' "noPerms/forz"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+

test/HPath/IO/MoveFileOverwriteSpec.hs

@@ -0,0 +1,126 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.MoveFileOverwriteSpec where
+
+
+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 "MoveFileOverwriteSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.moveFile" $ do
+
+    -- successes --
+    it "moveFile (Overwrite), all fine" $
+      moveFile' "myFile"
+                "movedFile"
+                Overwrite
+
+    it "moveFile (Overwrite), all fine" $
+      moveFile' "myFile"
+                "dir/movedFile"
+                Overwrite
+
+    it "moveFile (Overwrite), all fine on symlink" $
+      moveFile' "myFileL"
+                "movedFile"
+                Overwrite
+
+    it "moveFile (Overwrite), all fine on directory" $
+      moveFile' "dir"
+                "movedFile"
+                Overwrite
+
+    it "moveFile (Overwrite), destination file already exists" $
+      moveFile' "myFile"
+                "alreadyExists"
+                Overwrite
+
+    -- posix failures --
+    it "moveFile (Overwrite), source file does not exist" $
+      moveFile' "fileDoesNotExist"
+                "movedFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "moveFile (Overwrite), can't write to destination directory" $
+      moveFile' "myFile"
+                "noWritePerm/movedFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "moveFile (Overwrite), can't open destination directory" $
+      moveFile' "myFile"
+                "noPerms/movedFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "moveFile (Overwrite), can't open source directory" $
+      moveFile' "noPerms/myFile"
+                "movedFile"
+                Overwrite
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    -- custom failures --
+
+    it "moveFile (Overwrite), move from file to dir" $
+      moveFile' "myFile"
+                "alreadyExistsD"
+                Overwrite
+        `shouldThrow`
+        isDirDoesExist
+
+    it "moveFile (Overwrite), source and dest are same file" $
+      moveFile' "myFile"
+                "myFile"
+                Overwrite
+        `shouldThrow`
+        isSameFile

test/HPath/IO/MoveFileSpec.hs

@@ -0,0 +1,129 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.MoveFileSpec where
+
+
+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 "MoveFileSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.moveFile" $ do
+
+    -- successes --
+    it "moveFile (Strict), all fine" $
+      moveFile' "myFile"
+                "movedFile"
+                Strict
+
+    it "moveFile (Strict), all fine" $
+      moveFile' "myFile"
+                "dir/movedFile"
+                Strict
+
+    it "moveFile (Strict), all fine on symlink" $
+      moveFile' "myFileL"
+                "movedFile"
+                Strict
+
+    it "moveFile (Strict), all fine on directory" $
+      moveFile' "dir"
+                "movedFile"
+                Strict
+
+    -- posix failures --
+    it "moveFile (Strict), source file does not exist" $
+      moveFile' "fileDoesNotExist"
+                "movedFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "moveFile (Strict), can't write to destination directory" $
+      moveFile' "myFile"
+                "noWritePerm/movedFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "moveFile (Strict), can't open destination directory" $
+      moveFile' "myFile"
+                "noPerms/movedFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "moveFile (Strict), can't open source directory" $
+      moveFile' "noPerms/myFile"
+                "movedFile"
+                Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    -- custom failures --
+    it "moveFile (Strict), destination file already exists" $
+      moveFile' "myFile"
+                "alreadyExists"
+                Strict
+        `shouldThrow`
+        isFileDoesExist
+
+    it "moveFile (Strict), move from file to dir" $
+      moveFile' "myFile"
+                "alreadyExistsD"
+                Strict
+        `shouldThrow`
+        isDirDoesExist
+
+    it "moveFile (Strict), source and dest are same file" $
+      moveFile' "myFile"
+                "myFile"
+                Strict
+        `shouldThrow`
+        isSameFile

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
+

test/HPath/IO/RecreateSymlinkSpec.hs

@@ -0,0 +1,130 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.RecreateSymlinkSpec where
+
+
+
+
+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 "RecreateSymlinkSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.recreateSymlink" $ do
+
+    -- successes --
+    it "recreateSymLink (Strict), all fine" $ do
+      recreateSymlink' "myFileL"
+                       "movedFile"
+                       Strict
+      removeFileIfExists "movedFile"
+
+    it "recreateSymLink (Strict), all fine" $ do
+      recreateSymlink' "myFileL"
+                       "dir/movedFile"
+                       Strict
+      removeFileIfExists "dir/movedFile"
+
+    -- posix failures --
+    it "recreateSymLink (Strict), wrong input type (file)" $
+      recreateSymlink' "myFile"
+                       "movedFile"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "recreateSymLink (Strict), wrong input type (directory)" $
+      recreateSymlink' "dir"
+                       "movedFile"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == InvalidArgument)
+
+    it "recreateSymLink (Strict), can't write to destination directory" $
+      recreateSymlink' "myFileL"
+                       "noWritePerm/movedFile"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "recreateSymLink (Strict), can't open destination directory" $
+      recreateSymlink' "myFileL"
+                       "noPerms/movedFile"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "recreateSymLink (Strict), can't open source directory" $
+      recreateSymlink' "noPerms/myFileL"
+                       "movedFile"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "recreateSymLink (Strict), destination file already exists" $
+      recreateSymlink' "myFileL"
+                       "alreadyExists"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "recreateSymLink (Strict), destination already exists and is a dir" $
+      recreateSymlink' "myFileL"
+                       "alreadyExistsD"
+                       Strict
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    -- custom failures --
+    it "recreateSymLink (Strict), source and destination are the same file" $
+      recreateSymlink' "myFileL"
+                       "myFileL"
+                       Strict
+        `shouldThrow`
+        isSameFile
+

test/HPath/IO/RenameFileSpec.hs

@@ -0,0 +1,117 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module HPath.IO.RenameFileSpec where
+
+
+import Test.Hspec
+import HPath.IO.Errors
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RenameFileSpec"
+  createTmpDir
+
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "HPath.IO.renameFile" $ do
+
+    -- successes --
+    it "renameFile, all fine" $
+      renameFile' "myFile"
+                  "renamedFile"
+
+    it "renameFile, all fine" $
+      renameFile' "myFile"
+                  "dir/renamedFile"
+
+    it "renameFile, all fine on symlink" $
+      renameFile' "myFileL"
+                  "renamedFile"
+
+    it "renameFile, all fine on directory" $
+      renameFile' "dir"
+                  "renamedFile"
+
+    -- posix failures --
+    it "renameFile, source file does not exist" $
+      renameFile' "fileDoesNotExist"
+                  "renamedFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "renameFile, can't write to output directory" $
+      renameFile' "myFile"
+                  "noWritePerm/renamedFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "renameFile, can't open output directory" $
+      renameFile' "myFile"
+                  "noPerms/renamedFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "renameFile, can't open source directory" $
+      renameFile' "noPerms/myFile"
+                  "renamedFile"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    -- custom failures --
+    it "renameFile, destination file already exists" $
+      renameFile' "myFile"
+                  "alreadyExists"
+        `shouldThrow`
+        isFileDoesExist
+
+    it "renameFile, move from file to dir" $
+      renameFile' "myFile"
+                  "alreadyExistsD"
+        `shouldThrow`
+        isDirDoesExist
+
+    it "renameFile, source and dest are same file" $
+      renameFile' "myFile"
+                  "myFile"
+        `shouldThrow`
+        isSameFile
+

test/Main.hs

@@ -1,225 +1,19 @@
-{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE OverloadedStrings #-}
 
--- | Test suite.
-
-module Main where
-
-import Control.Applicative
-import Control.Monad
-import Data.Maybe
-import Data.Monoid
-import HPath
-import HPath.Internal
 import Test.Hspec
+import Test.Hspec.Runner
+import Test.Hspec.Formatters
+import qualified Spec
+import Utils
+
+
+-- TODO: chardev, blockdev, namedpipe, socket
+
 
--- | Test suite entry point, returns exit failure if any test fails.
 main :: IO ()
-main = hspec spec
-
--- | Test suite.
-spec :: Spec
-spec =
-  do describe "Parsing: Path Abs Dir" parseAbsTPSSpec
-     describe "Parsing: Path Rel Dir" parseRelTPSSpec
-     describe "Parsing: Path Abs File" parseAbsNoTPSSpec
-     describe "Parsing: Path Rel File" parseRelNoTPSSpec
-     describe "Operations: (</>)" operationAppend
-     describe "Operations: stripDir" operationStripDir
-     describe "Operations: isParentOf" operationIsParentOf
-     describe "Operations: dirname" operationDirname
-     describe "Operations: basename" operationBasename
-     describe "Restrictions" restrictions
-
--- | Restricting the input of any tricks.
-restrictions :: Spec
-restrictions =
-  do parseFails "~/"
-     parseFails "~/foo"
-     parseFails "~/foo/bar"
-     parseFails "../"
-     parseFails ".."
-     parseFails "."
-     parseFails "/.."
-     parseFails "/foo/../bar/"
-     parseFails "/foo/bar/.."
-  where parseFails x =
-          it (show x ++ " should be rejected")
-             (isNothing (void (parseAbsTPS x) <|>
-                         void (parseRelTPS x) <|>
-                         void (parseAbsNoTPS x) <|>
-                         void (parseRelNoTPS x)))
-
--- | The 'basename' operation.
-operationBasename :: Spec
-operationBasename =
-  do it "basename ($(mkAbsTPS parent) </> basename $(mkRelNoTPS filename)) == $(mkRelNoTPS filename)"
-        ((basename =<< ($(mkAbsTPS "/home/hasufell/") </>)
-                        <$> basename $(mkRelNoTPS "bar.txt")) ==
-         Just $(mkRelNoTPS "bar.txt"))
-     it "basename ($(mkRelTPS parent) </> basename $(mkRelNoTPS filename)) == $(mkRelNoTPS filename)"
-        ((basename =<< ($(mkRelTPS "home/hasufell/") </>)
-                        <$> basename $(mkRelNoTPS "bar.txt")) ==
-         Just $(mkRelNoTPS "bar.txt"))
-
--- | The 'dirname' operation.
-operationDirname :: Spec
-operationDirname =
-  do it "dirname (parent </> child) == parent"
-        (dirname ($(mkAbsTPS "/foo") </>
-                    $(mkRelTPS "bar")) ==
-         $(mkAbsTPS "/foo"))
-     it "dirname \"\" == \"\""
-        (dirname $(mkAbsTPS "/") ==
-         $(mkAbsTPS "/"))
-     it "dirname (parent \"\") == \"\""
-        (dirname (dirname $(mkAbsTPS "/")) ==
-         $(mkAbsTPS "/"))
-
--- | The 'isParentOf' operation.
-operationIsParentOf :: Spec
-operationIsParentOf =
-  do it "isParentOf parent (parent </> child)"
-        (isParentOf
-           $(mkAbsTPS "///bar/")
-           ($(mkAbsTPS "///bar/") </>
-            $(mkRelNoTPS "bar/foo.txt")))
-     it "isParentOf parent (parent </> child)"
-        (isParentOf
-           $(mkRelTPS "bar/")
-           ($(mkRelTPS "bar/") </>
-            $(mkRelNoTPS "bob/foo.txt")))
-
--- | The 'stripDir' operation.
-operationStripDir :: Spec
-operationStripDir =
-  do it "stripDir parent (parent </> child) = child"
-        (stripDir $(mkAbsTPS "///bar/")
-                  ($(mkAbsTPS "///bar/") </>
-                   $(mkRelNoTPS "bar/foo.txt")) ==
-         Just $(mkRelNoTPS "bar/foo.txt"))
-     it "stripDir parent (parent </> child) = child"
-        (stripDir $(mkRelTPS "bar/")
-                  ($(mkRelTPS "bar/") </>
-                   $(mkRelNoTPS "bob/foo.txt")) ==
-         Just $(mkRelNoTPS "bob/foo.txt"))
-     it "stripDir parent parent = _|_"
-        (stripDir $(mkAbsTPS "/home/hasufell/foo")
-                  $(mkAbsTPS "/home/hasufell/foo") ==
-         Nothing)
-
--- | The '</>' operation.
-operationAppend :: Spec
-operationAppend =
-  do it "AbsDir + RelDir = AbsDir"
-        ($(mkAbsTPS "/home/") </>
-         $(mkRelTPS "hasufell") ==
-         $(mkAbsTPS "/home/hasufell/"))
-     it "AbsDir + RelFile = AbsFile"
-        ($(mkAbsTPS "/home/") </>
-         $(mkRelNoTPS "hasufell/test.txt") ==
-         $(mkAbsNoTPS "/home/hasufell/test.txt"))
-     it "RelDir + RelDir = RelDir"
-        ($(mkRelTPS "home/") </>
-         $(mkRelTPS "hasufell") ==
-         $(mkRelTPS "home/hasufell"))
-     it "RelDir + RelFile = RelFile"
-        ($(mkRelTPS "home/") </>
-         $(mkRelNoTPS "hasufell/test.txt") ==
-         $(mkRelNoTPS "home/hasufell/test.txt"))
-
--- | Tests for the tokenizer.
-parseAbsTPSSpec :: Spec
-parseAbsTPSSpec =
-  do failing ""
-     failing "./"
-     failing "~/"
-     failing "foo.txt"
-     succeeding "/" (MkPath "/")
-     succeeding "//" (MkPath "/")
-     succeeding "///foo//bar//mu/" (MkPath "/foo/bar/mu/")
-     succeeding "///foo//bar////mu" (MkPath "/foo/bar/mu/")
-     succeeding "///foo//bar/.//mu" (MkPath "/foo/bar/mu/")
-  where failing x = parserTest parseAbsTPS x Nothing
-        succeeding x with = parserTest parseAbsTPS x (Just with)
-
--- | Tests for the tokenizer.
-parseRelTPSSpec :: Spec
-parseRelTPSSpec =
-  do failing ""
-     failing "/"
-     failing "//"
-     failing "~/"
-     failing "/"
-     failing "./"
-     failing "././"
-     failing "//"
-     failing "///foo//bar//mu/"
-     failing "///foo//bar////mu"
-     failing "///foo//bar/.//mu"
-     succeeding "..." (MkPath ".../")
-     succeeding "foo.bak" (MkPath "foo.bak/")
-     succeeding "./foo" (MkPath "foo/")
-     succeeding "././foo" (MkPath "foo/")
-     succeeding "./foo/./bar" (MkPath "foo/bar/")
-     succeeding "foo//bar//mu//" (MkPath "foo/bar/mu/")
-     succeeding "foo//bar////mu" (MkPath "foo/bar/mu/")
-     succeeding "foo//bar/.//mu" (MkPath "foo/bar/mu/")
-  where failing x = parserTest parseRelTPS x Nothing
-        succeeding x with = parserTest parseRelTPS x (Just with)
-
--- | Tests for the tokenizer.
-parseAbsNoTPSSpec :: Spec
-parseAbsNoTPSSpec =
-  do failing ""
-     failing "./"
-     failing "~/"
-     failing "./foo.txt"
-     failing "/"
-     failing "//"
-     failing "///foo//bar//mu/"
-     succeeding "/..." (MkPath "/...")
-     succeeding "/foo.txt" (MkPath "/foo.txt")
-     succeeding "///foo//bar////mu.txt" (MkPath "/foo/bar/mu.txt")
-     succeeding "///foo//bar/.//mu.txt" (MkPath "/foo/bar/mu.txt")
-  where failing x = parserTest parseAbsNoTPS x Nothing
-        succeeding x with = parserTest parseAbsNoTPS x (Just with)
-
--- | Tests for the tokenizer.
-parseRelNoTPSSpec :: Spec
-parseRelNoTPSSpec =
-  do failing ""
-     failing "/"
-     failing "//"
-     failing "~/"
-     failing "/"
-     failing "./"
-     failing "//"
-     failing "///foo//bar//mu/"
-     failing "///foo//bar////mu"
-     failing "///foo//bar/.//mu"
-     succeeding "..." (MkPath "...")
-     succeeding "foo.txt" (MkPath "foo.txt")
-     succeeding "./foo.txt" (MkPath "foo.txt")
-     succeeding "././foo.txt" (MkPath "foo.txt")
-     succeeding "./foo/./bar.txt" (MkPath "foo/bar.txt")
-     succeeding "foo//bar//mu.txt" (MkPath "foo/bar/mu.txt")
-     succeeding "foo//bar////mu.txt" (MkPath "foo/bar/mu.txt")
-     succeeding "foo//bar/.//mu.txt" (MkPath "foo/bar/mu.txt")
-  where failing x = parserTest parseRelNoTPS x Nothing
-        succeeding x with = parserTest parseRelNoTPS x (Just with)
-
--- | Parser test.
-parserTest :: (Show a1,Show a,Eq a1)
-           => (a -> Maybe a1) -> a -> Maybe a1 -> SpecWith ()
-parserTest parser input expected =
-  it ((case expected of
-         Nothing -> "Failing: "
-         Just{} -> "Succeeding: ") <>
-      "Parsing " <>
-      show input <>
-      " " <>
-      case expected of
-        Nothing -> "should fail."
-        Just x -> "should succeed with: " <> show x)
-     (actual == expected)
-  where actual = parser input
+main =
+  hspecWith
+    defaultConfig { configFormatter = Just progress }
+    $ beforeAll_ createBaseTmpDir
+    $ afterAll_ deleteBaseTmpDir
+    $ Spec.spec

test/Spec.hs

@@ -0,0 +1,2 @@
+-- file test/Spec.hs
+{-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-}

test/Utils.hs

@@ -0,0 +1,284 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PackageImports #-}
+
+
+module Utils where
+
+
+import Control.Applicative
+  (
+    (<$>)
+  )
+import Control.Monad
+  (
+    forM_
+  , void
+  )
+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 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
+  )
+import Data.ByteString
+  (
+    ByteString
+  )
+import System.Posix.Files.ByteString
+  (
+    groupExecuteMode
+  , groupReadMode
+  , nullFileMode
+  , otherExecuteMode
+  , otherReadMode
+  , ownerExecuteMode
+  , ownerReadMode
+  , setFileMode
+  , unionFileModes
+  )
+
+import qualified "unix" System.Posix.IO.ByteString as SPI
+import qualified "unix-bytestring" System.Posix.IO.ByteString as SPB
+
+
+
+baseTmpDir :: ByteString
+baseTmpDir = "test/HPath/IO/tmp/"
+
+
+tmpDir :: IORef ByteString
+{-# NOINLINE tmpDir #-}
+tmpDir = unsafePerformIO (newIORef baseTmpDir)
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+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 =<< readIORef tmpDir
+  void $ createDir newDirPerms (pwd P.</> tmp)
+
+
+deleteTmpDir :: IO ()
+{-# NOINLINE deleteTmpDir #-}
+deleteTmpDir = do
+  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
+  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 =<< 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 =<< readIORef tmpDir
+  p <- (pwd P.</> tmp P.</>) <$> P.parseRel ip
+  f p
+
+
+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 =<< 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 -> CopyMode -> IO ()
+{-# NOINLINE copyFile' #-}
+copyFile' inputFileP outputFileP cm =
+  withTmpDir' inputFileP outputFileP (\p1 p2 -> copyFile p1 p2 cm)
+
+
+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 ()
+{-# NOINLINE createDir' #-}
+createDir' dest = withTmpDir dest (createDir newDirPerms)
+
+
+createRegularFile' :: ByteString -> IO ()
+{-# 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 -> CopyMode -> IO ()
+{-# NOINLINE moveFile' #-}
+moveFile' inputFileP outputFileP cm =
+  withTmpDir' inputFileP outputFileP $ \i o -> do
+    moveFile i o cm
+    moveFile o i Strict
+
+
+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
+    perms =            ownerReadMode
+      `unionFileModes` ownerExecuteMode
+      `unionFileModes` groupReadMode
+      `unionFileModes` groupExecuteMode
+      `unionFileModes` otherReadMode
+      `unionFileModes` otherExecuteMode
+
+
+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
+
+
+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
+
+
+allDirectoryContents' :: ByteString -> IO [ByteString]
+{-# NOINLINE allDirectoryContents' #-}
+allDirectoryContents' ip =
+  withTmpDir ip $ \p -> DT.allDirectoryContents' (P.fromAbs p)
+

update-gh-pages.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+SOURCE_BRANCH="master"
+TARGET_BRANCH="gh-pages"
+REPO="https://${GH_TOKEN}@github.com/hasufell/hpath"
+DOC_LOCATION="/dist/doc/html/hpath"
+
+
+# Pull requests and commits to other branches shouldn't try to deploy,
+# just build to verify
+if [ "$TRAVIS_PULL_REQUEST" != "false" -o "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]; then
+    echo "Skipping docs deploy."
+    exit 0
+fi
+
+
+cd "$HOME"
+git config --global user.email "travis@travis-ci.org"
+git config --global user.name "travis-ci"
+git clone --branch=${TARGET_BRANCH} ${REPO} ${TARGET_BRANCH} || exit 1
+
+# docs
+cd ${TARGET_BRANCH} || exit 1
+echo "Removing old docs."
+rm -rf *
+echo "Adding new docs."
+cp -rf "${TRAVIS_BUILD_DIR}${DOC_LOCATION}"/* . || exit 1
+
+# If there are no changes to the compiled out (e.g. this is a README update)
+# then just bail.
+if [ -z "`git diff --exit-code`" ]; then
+    echo "No changes to the output on this push; exiting."
+    exit 0
+fi
+
+git add -- .
+
+if [[ -e ./index.html ]] ; then
+	echo "Commiting docs."
+	git commit -m "Lastest docs updated
+
+travis build: $TRAVIS_BUILD_NUMBER
+commit: $TRAVIS_COMMIT
+auto-pushed to gh-pages"
+
+	git push origin $TARGET_BRANCH
+	echo "Published docs to gh-pages."
+else
+	echo "Error: docs are empty."
+	exit 1
+fi
+