Fix build on GHC-7.10.3

Also add getDirsFilesStream.

.ghci

@@ -1,2 +0,0 @@
-:set -package HUnit -package hspec
-:set -package template-haskell

.gitignore

@@ -8,5 +8,7 @@ TAGS
 tags
 *.tag
 .stack-work/
+dist/
+dist-newstyle/
 .cabal-sandbox/
 cabal.sandbox.config

.travis.yml

@@ -7,53 +7,76 @@ 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=3.0 GHCVER=7.10.3 SKIP_DOCTESTS=yes
+      addons: {apt: {packages: [cabal-install-3.0,ghc-7.10.3], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - env: CABALVER=3.0 GHCVER=8.0.2 SKIP_DOCTESTS=yes
+      addons: {apt: {packages: [cabal-install-3.0,ghc-8.0.2], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - env: CABALVER=3.0 GHCVER=8.2.2
+      addons: {apt: {packages: [cabal-install-3.0,ghc-8.2.2], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - env: CABALVER=3.0 GHCVER=8.4.4
+      addons: {apt: {packages: [cabal-install-3.0,ghc-8.4.4], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - env: CABALVER=3.0 GHCVER=8.6.5
+      addons: {apt: {packages: [cabal-install-3.0,ghc-8.6.5], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - env: CABALVER=3.0 GHCVER=8.8.3
+      addons: {apt: {packages: [cabal-install-3.0,ghc-8.8.3], sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
     - env: CABALVER=head GHCVER=head
       addons: {apt: {packages: [cabal-install-head,ghc-head],  sources: [hvr-ghc]}}
+      before_install:
+       - sudo apt-get install -y hscolour
+       - export PATH=~/.cabal/bin:/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+    - os: osx
+      osx_image: xcode11.3
+      language: generic
+      before_install:
+       - mkdir -p ~/.ghcup/bin
+       - curl https://gitlab.haskell.org/haskell/ghcup/raw/master/ghcup > ~/.ghcup/bin/ghcup
+       - chmod +x ~/.ghcup/bin/ghcup
+       - export PATH=~/.cabal/bin:~/.ghcup/bin:$PATH
+       - ghcup install 8.6.5
+       - ghcup set 8.6.5
+       - ghcup install-cabal 3.2.0.0
 
   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
+    - secure: HPBARvNM85ea2U0Ynq5MMe6BRlnuwqXWuSn20VY3EYCAT2njkVPYnR3O7+bGE6aq0KHAV87zz5iUfGJontd86tE0sDVjcSuRY0hqjOeJTkQq5M8WXJZOpVqlBTwDP1Q3x/fwoRa0dt9Z0tZZdKMlrf2XdcKPDdhcP1QYP4aV/jO4ZCfAQr7zVCvTae+Lp/KmwFYcBbFo/pj0duF1M4Oqx/D388b/W4jVE3lgd/TK7Ja1xWP6g+Oyvo6iQK8yJVYGdm6E+cVsNueiisnTJ/rRA53lsaC9dmWtZaFGl41wPviSU5zPq03vOuZMiyE2WtCHoo46ONXrXJ9N2soqdQVfEkr9Nw5LQl+6C5lCPEejZ575YUkuO05H3wvHMk3YY4zWXNFA9eZ47PEH8tpoUk9LPBacCKQFtp5lfRk63crba5CiFtcMyFq++0mLpNthNvtto7ffHMZrt6fvK9axI+r21VPftf/3FiFY4mnCp/Bln+ijklfZSN71VqiT20EWuqxQHw8aCpT00KA/PKGl9iJfoN4OO3XzNRTtmM+L9Im4bc1ni9YQ6N3UYg3z0nEnCLwFcTmTH/tDMHRremE0dM6B++YfcnyIhen8w+hG4bcXk7jbMUizRhUhStN7TZQuC9S4wE5whhp9c03rJZMmH5E2rlXY3lwVgeyWm1TuMp1RYWI=
 
 install:
  - cabal --version
  - travis_retry cabal update
- - cabal sandbox init
- - cabal install --only-dependencies --enable-tests -j
+ - cabal install --installdir=$HOME/.cabal/bin hspec-discover
+ - cabal install --installdir=$HOME/.cabal/bin doctest
 
 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
+ - cabal build --enable-tests all
+ - cabal test all
+ - ./hpath/run-doctests.sh
+ - ./hpath-filepath/run-doctests.sh
+ - (cd hpath && cabal check)
+ - (cd hpath-filepath && cabal check)
+ - (cd hpath-io && cabal check)
+ - cabal sdist all
+ - cabal install --lib all
 
 notifications:
   email:

LICENSE

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

README.md

@@ -1,87 +1,19 @@
-# HPath
+# HPath libraries
 
-[![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)
+[![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) [![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.
+Set of libraries to deal with filepaths and files.
 
 ## Motivation
 
-The motivation came during development of
-[hsfm](https://github.com/hasufell/hsfm)
-which has a pretty strict File type, but lacks a strict Path type, e.g.
-for user input.
+* filepaths should be type-safe (absolute, relative, ...)
+* filepaths should be ByteString under the hood, see [Abstract FilePath Proposal (AFPP)](https://gitlab.haskell.org/ghc/ghc/wikis/proposal/abstract-file-path)
+* file high-level operations should be platform-specific, exception-stable, safe and as atomic as possible
 
-The library that came closest to my needs was
-[path](https://github.com/chrisdone/path),
-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'
-
-* 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
-
-## Differences to 'posix-paths'
-
-* 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
-
-## Examples in ghci
-
-Start ghci via `cabal repl`:
-
-```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)
-```
+## Projects
 
+* [![Hackage version](https://img.shields.io/hackage/v/hpath.svg?label=Hackage)](https://hackage.haskell.org/package/hpath) [hpath](./hpath): Support for well-typed paths
+* [![Hackage version](https://img.shields.io/hackage/v/hpath-filepath.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-filepath) [hpath-filepath](./hpath-filepath): ByteString based filepath manipulation (can be used without hpath)
+* [![Hackage version](https://img.shields.io/hackage/v/hpath-directory.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-directory) [hpath-directory](./hpath-directory): High-level IO operations for files/directories on raw ByteString filepaths (use hpath-io for the type-safe path version)
+* [![Hackage version](https://img.shields.io/hackage/v/hpath-io.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-io) [hpath-io](./hpath-io): High-level IO operations for files/directories utilizing type-safe Path
+* [![Hackage version](https://img.shields.io/hackage/v/hpath-posix.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-posix) [hpath-posix](./hpath-posix): Some low-level POSIX glue code that is not in 'unix'

cabal.project

@@ -0,0 +1,12 @@
+packages: ./hpath
+          ./hpath-directory
+          ./hpath-filepath
+          ./hpath-io
+          ./hpath-posix
+
+package hpath-io
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+-- https://github.com/composewell/streamly/blob/master/docs/Build.md
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

doctests-hpath.hs

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

doctests-posix.hs

@@ -1,25 +0,0 @@
-{-# 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-directory/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Revision history for hpath-directory
+
+## 0.13.4 -- 2020-05-08
+
+* Add getDirsFilesStream and use streamly-posix for dircontents (#34)
+
+## 0.13.3 -- 2020-04-14
+
+* Fix tests on mac
+
+## 0.13.2 -- 2020-02-17
+
+* Fix bug in `createDirRecursive` with trailing path separators
+
+## 0.13.1 -- 2020-01-29
+
+* Split some functionality out into 'hpath-posix'
+
+## 0.1.0.0 -- 2020-01-26
+
+* First version. Released on an unsuspecting world.

hpath-directory/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2020, 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
+      notice, this list of conditions and the following disclaimer.
+
+    * 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 Julian Ospald nor the names of other
+      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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER 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.

hpath-directory/README.md

@@ -0,0 +1,21 @@
+# HPath-filepath
+
+[![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-directory.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-directory) [![Build Status](https://api.travis-ci.org/hasufell/hpath.png?branch=master)](http://travis-ci.org/hasufell/hpath) [![Hackage-Deps](https://img.shields.io/hackage-deps/v/hpath-directory.svg)](http://packdeps.haskellers.com/feed?needle=hpath-directory)
+
+Support high-level IO operations on files/directories, utilizing ByteString
+as FilePaths.
+
+This package is part of the HPath suite, also check out:
+
+* [hpath](https://hackage.haskell.org/package/hpath)
+* [hpath-filepath](https://hackage.haskell.org/package/hpath-filepath)
+* [hpath-io](https://hackage.haskell.org/package/hpath-io)
+
+## Motivation
+
+This is basically a fork of [directory](https://hackage.haskell.org/package/directory), but is a complete rewrite and the API doesn't follow the directory package.
+
+## Differences to 'posix-paths'
+
+* 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

hpath-directory/hpath-directory.cabal

@@ -0,0 +1,116 @@
+cabal-version:       >=1.10
+
+name:                hpath-directory
+version:             0.13.4
+synopsis:            Alternative to 'directory' package with ByteString based filepaths
+description:         This provides a safer alternative to the 'directory'
+                     package. FilePaths are ByteString based, so this
+                     package only works on POSIX systems.
+
+                     For a more high-level version of this with
+                     proper Path type, use 'hpath-io', which makes
+                     use of this package.
+homepage:            https://github.com/hasufell/hpath
+bug-reports:         https://github.com/hasufell/hpath/issues
+license:             BSD3
+license-file:        LICENSE
+author:              Julian Ospald <hasufell@posteo.de>
+maintainer:          Julian Ospald <hasufell@posteo.de>
+copyright:           Julian Ospald <hasufell@posteo.de> 2020
+category:            Filesystem
+build-type:          Simple
+extra-source-files:  CHANGELOG.md
+tested-with:         GHC==7.10.3
+                   , GHC==8.0.2
+                   , GHC==8.2.2
+                   , GHC==8.4.4
+                   , GHC==8.6.5
+                   , GHC==8.8.1
+
+library
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  exposed-modules:     System.Posix.RawFilePath.Directory
+                       System.Posix.RawFilePath.Directory.Errors
+  -- other-modules:
+  -- other-extensions:
+  build-depends:         base                >= 4.8  && <5
+                       , IfElse
+                       , bytestring          >= 0.10
+                       , exceptions          >= 0.10
+                       , hpath-filepath      >= 0.10.3
+                       , hpath-posix         >= 0.13
+                       , safe-exceptions     >= 0.1
+                       , streamly            >= 0.7
+                       , streamly-bytestring >= 0.1.2
+                       , streamly-posix      >= 0.1.0.1
+                       , time                >= 1.8
+                       , transformers
+                       , unix                >= 2.5
+                       , unix-bytestring     >= 0.3
+                       , utf8-string
+  if impl(ghc < 8.0)
+    build-depends:
+        fail >= 4.9
+
+  hs-source-dirs:      src
+  default-language:    Haskell2010
+  default-extensions: PackageImports
+
+test-suite spec
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  Type:                 exitcode-stdio-1.0
+  Default-Language:     Haskell2010
+  Hs-Source-Dirs:       test
+  Main-Is:              Main.hs
+  other-modules:
+                        System.Posix.RawFilePath.Directory.AppendFileSpec
+                        System.Posix.RawFilePath.Directory.CanonicalizePathSpec
+                        System.Posix.RawFilePath.Directory.CopyDirRecursiveCollectFailuresSpec
+                        System.Posix.RawFilePath.Directory.CopyDirRecursiveOverwriteSpec
+                        System.Posix.RawFilePath.Directory.CopyDirRecursiveSpec
+                        System.Posix.RawFilePath.Directory.CopyFileOverwriteSpec
+                        System.Posix.RawFilePath.Directory.CopyFileSpec
+                        System.Posix.RawFilePath.Directory.CreateDirIfMissingSpec
+                        System.Posix.RawFilePath.Directory.CreateDirRecursiveSpec
+                        System.Posix.RawFilePath.Directory.CreateDirSpec
+                        System.Posix.RawFilePath.Directory.CreateRegularFileSpec
+                        System.Posix.RawFilePath.Directory.CreateSymlinkSpec
+                        System.Posix.RawFilePath.Directory.DeleteDirRecursiveSpec
+                        System.Posix.RawFilePath.Directory.DeleteDirSpec
+                        System.Posix.RawFilePath.Directory.DeleteFileSpec
+                        System.Posix.RawFilePath.Directory.GetDirsFilesSpec
+                        System.Posix.RawFilePath.Directory.GetFileTypeSpec
+                        System.Posix.RawFilePath.Directory.MoveFileOverwriteSpec
+                        System.Posix.RawFilePath.Directory.MoveFileSpec
+                        System.Posix.RawFilePath.Directory.ReadFileSpec
+                        System.Posix.RawFilePath.Directory.RecreateSymlinkOverwriteSpec
+                        System.Posix.RawFilePath.Directory.RecreateSymlinkSpec
+                        System.Posix.RawFilePath.Directory.RenameFileSpec
+                        System.Posix.RawFilePath.Directory.ToAbsSpec
+                        System.Posix.RawFilePath.Directory.WriteFileLSpec
+                        System.Posix.RawFilePath.Directory.WriteFileSpec
+                        Spec
+                        Utils
+  GHC-Options:          -Wall
+  Build-Depends:        base
+                      , HUnit
+                      , IfElse
+                      , bytestring >= 0.10.0.0
+                      , hpath-directory
+                      , hpath-filepath >= 0.10
+                      , hpath-posix    >= 0.13
+                      , hspec >= 1.3
+                      , process
+                      , time >= 1.8
+                      , unix
+                      , unix-bytestring
+                      , utf8-string
+  default-extensions: PackageImports
+
+source-repository head
+  type:     git
+  location: https://github.com/hasufell/hpath

hpath-directory/src/System/Posix/RawFilePath/Directory.hs-boot

@@ -0,0 +1,15 @@
+module System.Posix.RawFilePath.Directory where
+
+import System.Posix.ByteString.FilePath (RawFilePath)
+
+canonicalizePath :: RawFilePath -> IO RawFilePath
+
+toAbs :: RawFilePath -> IO RawFilePath
+
+doesFileExist :: RawFilePath -> IO Bool
+
+doesDirectoryExist :: RawFilePath -> IO Bool
+
+isWritable :: RawFilePath -> IO Bool
+
+canOpenDirectory :: RawFilePath -> IO Bool

hpath-directory/src/System/Posix/RawFilePath/Directory/Errors.hs

@@ -0,0 +1,327 @@
+-- |
+-- Module      :  System.Posix.RawFilePath.Directory.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 System.Posix.RawFilePath.Directory.Errors
+  (
+  -- * Types
+    HPathIOException(..)
+  , RecursiveFailureHint(..)
+
+  -- * Exception identifiers
+  , isSameFile
+  , isDestinationInSource
+  , isRecursiveFailure
+  , isReadContentsFailed
+  , isCreateDirFailed
+  , isCopyFileFailed
+  , isRecreateSymlinkFailed
+
+  -- * Path based functions
+  , throwFileDoesExist
+  , throwDirDoesExist
+  , throwSameFile
+  , sameFile
+  , throwDestinationInSource
+
+  -- * Error handling functions
+  , catchErrno
+  , rethrowErrnoAs
+  , handleIOError
+  , hideError
+  , bracketeer
+  , reactOnError
+  )
+  where
+
+
+import Control.Applicative
+  (
+    (<$>)
+  )
+import Control.Exception.Safe hiding (handleIOError)
+import Control.Monad
+  (
+    forM
+  , when
+  )
+import Control.Monad.IfElse
+  (
+    whenM
+  )
+import Data.ByteString
+  (
+    ByteString
+  )
+import qualified Data.ByteString as BS
+import Data.ByteString.UTF8
+  (
+    toString
+  )
+import Data.Typeable
+  (
+    Typeable
+  )
+import Foreign.C.Error
+  (
+    getErrno
+  , Errno
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType
+  )
+import {-# SOURCE #-} System.Posix.RawFilePath.Directory
+  (
+    canonicalizePath
+  , toAbs
+  , doesFileExist
+  , doesDirectoryExist
+  , isWritable
+  , canOpenDirectory
+  )
+import System.IO.Error
+  (
+    alreadyExistsErrorType
+  , ioeGetErrorType
+  , mkIOError
+  )
+import System.Posix.FilePath
+import qualified System.Posix.Directory.ByteString as PFD
+import System.Posix.Files.ByteString
+  (
+    fileAccess
+  , getFileStatus
+  )
+import qualified System.Posix.Files.ByteString as PF
+
+
+-- |Additional generic IO exceptions that the posix functions
+-- do not provide.
+data HPathIOException = SameFile ByteString ByteString
+                      | DestinationInSource ByteString ByteString
+                      | RecursiveFailure [(RecursiveFailureHint, IOException)]
+  deriving (Eq, Show, Typeable)
+
+
+-- |A type for giving failure hints on recursive failure, which allows
+-- to programmatically make choices without examining
+-- the weakly typed I/O error attributes (like `ioeGetFileName`).
+--
+-- The first argument to the data constructor is always the
+-- source and the second the destination.
+data RecursiveFailureHint = ReadContentsFailed    ByteString ByteString
+                          | CreateDirFailed       ByteString ByteString
+                          | CopyFileFailed        ByteString ByteString
+                          | RecreateSymlinkFailed ByteString ByteString
+  deriving (Eq, Show)
+
+
+instance Exception HPathIOException
+
+
+toConstr :: HPathIOException -> String
+toConstr SameFile {}            = "SameFile"
+toConstr DestinationInSource {} = "DestinationInSource"
+toConstr RecursiveFailure {}    = "RecursiveFailure"
+
+
+
+
+
+    -----------------------------
+    --[ Exception identifiers ]--
+    -----------------------------
+
+
+isSameFile, isDestinationInSource, isRecursiveFailure :: HPathIOException -> Bool
+isSameFile ex = toConstr (ex :: HPathIOException) == toConstr (SameFile mempty mempty)
+isDestinationInSource ex = toConstr (ex :: HPathIOException) == (toConstr $ DestinationInSource mempty mempty)
+isRecursiveFailure ex = toConstr (ex :: HPathIOException) == (toConstr $ RecursiveFailure mempty)
+
+
+isReadContentsFailed, isCreateDirFailed, isCopyFileFailed, isRecreateSymlinkFailed ::RecursiveFailureHint -> Bool
+isReadContentsFailed ReadContentsFailed{} = True
+isReadContentsFailed _ = False
+isCreateDirFailed CreateDirFailed{} = True
+isCreateDirFailed _ = False
+isCopyFileFailed CopyFileFailed{} = True
+isCopyFileFailed _ = False
+isRecreateSymlinkFailed RecreateSymlinkFailed{} = True
+isRecreateSymlinkFailed _ = False
+
+
+
+
+
+    ----------------------------
+    --[ Path based functions ]--
+    ----------------------------
+
+
+-- |Throws `AlreadyExists` `IOError` if file exists.
+throwFileDoesExist :: RawFilePath -> IO ()
+throwFileDoesExist bs =
+  whenM (doesFileExist bs)
+        (ioError . mkIOError
+                     alreadyExistsErrorType
+                     "File already exists"
+                     Nothing
+                   $ (Just (toString $ bs))
+        )
+
+
+-- |Throws `AlreadyExists` `IOError` if directory exists.
+throwDirDoesExist :: RawFilePath -> IO ()
+throwDirDoesExist bs =
+  whenM (doesDirectoryExist bs)
+        (ioError . mkIOError
+                     alreadyExistsErrorType
+                     "Directory already exists"
+                     Nothing
+                   $ (Just (toString $ bs))
+        )
+
+
+-- |Uses `isSameFile` and throws `SameFile` if it returns True.
+throwSameFile :: RawFilePath
+              -> RawFilePath
+              -> IO ()
+throwSameFile bs1 bs2 =
+  whenM (sameFile bs1 bs2)
+        (throwIO $ SameFile bs1 bs2)
+
+
+-- |Check if the files are the same by examining device and file id.
+-- This follows symbolic links.
+sameFile :: RawFilePath -> RawFilePath -> IO Bool
+sameFile fp1 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 :: RawFilePath -- ^ source dir
+                         -> RawFilePath -- ^ full destination, @dirname dest@
+                                        --   must exist
+                         -> IO ()
+throwDestinationInSource sbs dbs = do
+  destAbs <- toAbs dbs
+  dest'   <- (\x -> maybe x (\y -> x </> y) $ basename dbs)
+             <$> (canonicalizePath $ takeDirectory destAbs)
+  dids <- forM (takeAllParents dest') $ \p -> do
+          fs <- PF.getSymbolicLinkStatus p
+          return (PF.deviceID fs, PF.fileID fs)
+  sid <- fmap (\x -> (PF.deviceID x, PF.fileID x))
+              $ PF.getFileStatus sbs
+  when (elem sid dids)
+       (throwIO $ DestinationInSource dbs sbs)
+  where
+    basename x = let b = takeBaseName x
+                 in if BS.null b then Nothing else Just b
+
+
+
+    --------------------------------
+    --[ 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
+
+
+hideError :: IOErrorType -> IO () -> IO ()
+hideError err = handleIO (\e -> if err == ioeGetErrorType e then pure () else ioError e)
+
+
+-- |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
+
+

hpath-directory/test/Main.hs

@@ -0,0 +1,28 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+import qualified Data.ByteString as BS
+import Data.IORef
+import Test.Hspec
+import Test.Hspec.Runner
+import Test.Hspec.Formatters
+import qualified Spec
+import Utils
+import System.Posix.Temp.ByteString (mkdtemp)
+import System.Posix.Env.ByteString (getEnvDefault)
+import System.Posix.FilePath ((</>))
+import "hpath-directory" System.Posix.RawFilePath.Directory
+
+
+-- TODO: chardev, blockdev, namedpipe, socket
+
+
+main :: IO ()
+main = do
+  tmpdir <- getEnvDefault "TMPDIR" "/tmp" >>= canonicalizePath
+  tmpBase <- mkdtemp (tmpdir </> "hpath-directory")
+  writeIORef baseTmpDir (Just (tmpBase `BS.append` "/"))
+  putStrLn $ ("Temporary test directory at: " ++ show tmpBase)
+  hspecWith
+    defaultConfig { configFormatter = Just progress }
+    $ afterAll_ deleteBaseTmpDir
+    $ Spec.spec

hpath-directory/test/System/Posix/RawFilePath/Directory/AppendFileSpec.hs

@@ -0,0 +1,108 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.AppendFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "AppendFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "BLKASL"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.appendFile" $ do
+
+    -- successes --
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" "blahfaselllll"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllll"
+
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" "gagagaga"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllllgagagaga"
+
+    it "appendFile file with content, everything clear" $ do
+      appendFile' "fileWithContent" ""
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "BLKASLblahfaselllllgagagaga"
+
+    it "appendFile file without content, everything clear" $ do
+      appendFile' "fileWithoutContent" "blahfaselllll"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "appendFile, everything clear" $ do
+      appendFile' "fileWithoutContent" "gagagaga"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllllgagagaga"
+
+    it "appendFile symlink, everything clear" $ do
+      appendFile' "inputFileSymL" "blahfaselllll"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "BLKASLblahfaselllllgagagagablahfaselllll"
+
+    it "appendFile symlink, everything clear" $ do
+      appendFile' "inputFileSymL" "gagagaga"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "BLKASLblahfaselllllgagagagablahfaselllllgagagaga"
+
+
+    -- posix failures --
+    it "appendFile to dir, inappropriate type" $ do
+      appendFile' "alreadyExistsD" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "appendFile, no permissions to file" $ do
+      appendFile' "noPerms" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "appendFile, no permissions to file" $ do
+      appendFile' "noPermsD/inputFile" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "appendFile, file does not exist" $ do
+      appendFile' "gaga" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)

hpath-directory/test/System/Posix/RawFilePath/Directory/CanonicalizePathSpec.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.CanonicalizePathSpec where
+module System.Posix.RawFilePath.Directory.CanonicalizePathSpec where
 
 
 import Test.Hspec
@@ -13,12 +13,15 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
 
 
 
 
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CanonicalizePathSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
   createRegularFile' "file"
@@ -37,8 +40,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.canonicalizePath" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.canonicalizePath" $ do
 
     -- successes --
     it "canonicalizePath, all fine" $ do

hpath-directory/test/System/Posix/RawFilePath/Directory/CopyDirRecursiveCollectFailuresSpec.hs

@@ -0,0 +1,248 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.CopyDirRecursiveCollectFailuresSpec where
+
+
+import Test.Hspec
+import Data.List (sort)
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.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 "System.Posix.RawFilePath.Directory.copyDirRecursive" $ do
+
+    -- successes --
+    it "copyDirRecursive (Strict, CollectFailures), all fine and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyDirRecursive' "inputDir"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+      (system $ "diff -r "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir"
+                          ++ " >/dev/null")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+    -- posix failures --
+    it "copyDirRecursive (Strict, CollectFailures), source directory does not exist" $
+      copyDirRecursive' "doesNotExist"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "copyDirRecursive (Strict, CollectFailures), cannot open source dir" $
+      copyDirRecursive' "noPerms/inputDir"
+                        "foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+
+    -- custom failures
+    it "copyDirRecursive (Overwrite, CollectFailures), various failures" $ do
+      copyDirRecursive' "inputDir1/foo2"
+                        "outputDir1/foo2"
+                        Overwrite
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure ex@[_, _]) ->
+          any (\(h, e) -> ioeGetErrorType e == InappropriateType
+                          && isCopyFileFailed h) ex &&
+          any (\(h, e) -> ioeGetErrorType e == PermissionDenied
+                          && isReadContentsFailed h) ex)
+      normalDirPerms "outputDir1/foo2/foo4"
+      normalDirPerms "outputDir1/foo2/foo4/inputFile4"
+      c <- allDirectoryContents' "outputDir1"
+      tmpDir' <- getRawTmpDir
+      let shouldC = (fmap (\x -> tmpDir' `BS.append` x)
+                          ["outputDir1"
+                          ,"outputDir1/foo2"
+                          ,"outputDir1/foo2/inputFile1"
+                          ,"outputDir1/foo2/inputFile2"
+                          ,"outputDir1/foo2/inputFile3"
+                          ,"outputDir1/foo2/foo4"
+                          ,"outputDir1/foo2/foo4/inputFile6"
+                          ,"outputDir1/foo2/foo4/inputFile4"])
+      deleteFile' "outputDir1/foo2/inputFile1"
+      deleteFile' "outputDir1/foo2/inputFile2"
+      deleteFile' "outputDir1/foo2/inputFile3"
+      sort c `shouldBe` sort shouldC
+
+
+    it "copyDirRecursive (Strict, CollectFailures), no write permission on output dir" $
+      copyDirRecursive' "inputDir"
+                        "noWritePerm/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(CreateDirFailed{}, e)]) -> ioeGetErrorType e == PermissionDenied)
+
+    it "copyDirRecursive (Strict, CollectFailures), cannot open output dir" $
+      copyDirRecursive' "inputDir"
+                        "noPerms/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isRecursiveFailure
+
+    it "copyDirRecursive (Strict, CollectFailures), destination dir already exists" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(CreateDirFailed{}, e)]) -> ioeGetErrorType e == AlreadyExists)
+
+    it "copyDirRecursive (Strict, CollectFailures), destination already exists and is a file" $
+      copyDirRecursive' "inputDir"
+                        "alreadyExists"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isRecursiveFailure
+
+    it "copyDirRecursive (Strict, CollectFailures), wrong input (regular file)" $
+      copyDirRecursive' "wrongInput"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(ReadContentsFailed{}, e)]) -> ioeGetErrorType e == InappropriateType)
+
+    it "copyDirRecursive (Strict, CollectFailures), wrong input (symlink to directory)" $
+      copyDirRecursive' "wrongInputSymL"
+                        "outputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        (\(RecursiveFailure [(ReadContentsFailed{}, e)]) -> ioeGetErrorType e == InvalidArgument)
+
+    it "copyDirRecursive (Strict, CollectFailures), destination in source" $
+      copyDirRecursive' "inputDir"
+                        "inputDir/foo"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isDestinationInSource
+
+    it "copyDirRecursive (Strict, CollectFailures), destination and source same directory" $
+      copyDirRecursive' "inputDir"
+                        "inputDir"
+                        Strict
+                        CollectFailures
+        `shouldThrow`
+        isSameFile
+
+

hpath-directory/test/System/Posix/RawFilePath/Directory/CopyDirRecursiveOverwriteSpec.hs

@@ -0,0 +1,205 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.CopyDirRecursiveOverwriteSpec where
+
+
+import Test.Hspec
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.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 "System.Posix.RawFilePath.Directory.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 "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir"
+                          ++ " >/dev/null")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
+
+    it "copyDirRecursive (Overwrite, FailEarly), destination dir already exists" $ do
+      tmpDir' <- getRawTmpDir
+      (system $ "diff -r "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD"
+                          ++ " >/dev/null")
+        `shouldReturn` (ExitFailure 1)
+      copyDirRecursive' "inputDir"
+                        "alreadyExistsD"
+                        Overwrite
+                        FailEarly
+      (system $ "diff -r "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExistsD"
+                          ++ " >/dev/null")
+        `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

hpath-directory/test/System/Posix/RawFilePath/Directory/CopyDirRecursiveSpec.hs

@@ -1,11 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 
-module HPath.IO.CopyDirRecursiveSpec where
+module System.Posix.RawFilePath.Directory.CopyDirRecursiveSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -17,12 +18,14 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
-
+import Data.ByteString.UTF8 (toString)
 
 
 
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyDirRecursiveSpec"
+  createTmpDir
 
 setupFiles :: IO ()
 setupFiles = do
@@ -69,82 +72,110 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyDirRecursive" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.copyDirRecursive" $ do
 
     -- successes --
-    it "copyDirRecursive, all fine" $ do
+    it "copyDirRecursive (Strict, FailEarly), all fine" $ do
       copyDirRecursive' "inputDir"
                         "outputDir"
+                        Strict
+                        FailEarly
       removeDirIfExists "outputDir"
 
-    it "copyDirRecursive, all fine and compare" $ do
+    it "copyDirRecursive (Strict, FailEarly), all fine and compare" $ do
+      tmpDir' <- getRawTmpDir
       copyDirRecursive' "inputDir"
                         "outputDir"
-      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "outputDir")
+                        Strict
+                        FailEarly
+      (system $ "diff -r "
+                          ++ toString tmpDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir' ++ "outputDir"
+                          ++ " >/dev/null")
         `shouldReturn` ExitSuccess
       removeDirIfExists "outputDir"
 
     -- posix failures --
-    it "copyDirRecursive, source directory does not exist" $
+    it "copyDirRecursive (Strict, FailEarly), source directory does not exist" $
       copyDirRecursive' "doesNotExist"
                         "outputDir"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
-    it "copyDirRecursive, no write permission on output dir" $
+    it "copyDirRecursive (Strict, FailEarly), no write permission on output dir" $
       copyDirRecursive' "inputDir"
                         "noWritePerm/foo"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyDirRecursive, cannot open output dir" $
+    it "copyDirRecursive (Strict, FailEarly), cannot open output dir" $
       copyDirRecursive' "inputDir"
                         "noPerms/foo"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyDirRecursive, cannot open source dir" $
+    it "copyDirRecursive (Strict, FailEarly), cannot open source dir" $
       copyDirRecursive' "noPerms/inputDir"
                         "foo"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyDirRecursive, destination dir already exists" $
+    it "copyDirRecursive (Strict, FailEarly), destination dir already exists" $
       copyDirRecursive' "inputDir"
                         "alreadyExistsD"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "copyDirRecursive, destination already exists and is a file" $
+    it "copyDirRecursive (Strict, FailEarly), destination already exists and is a file" $
       copyDirRecursive' "inputDir"
                         "alreadyExists"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "copyDirRecursive, wrong input (regular file)" $
+    it "copyDirRecursive (Strict, FailEarly), wrong input (regular file)" $
       copyDirRecursive' "wrongInput"
                         "outputDir"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
-    it "copyDirRecursive, wrong input (symlink to directory)" $
+    it "copyDirRecursive (Strict, FailEarly), wrong input (symlink to directory)" $
       copyDirRecursive' "wrongInputSymL"
                         "outputDir"
+                        Strict
+                        FailEarly
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     -- custom failures
-    it "copyDirRecursive, destination in source" $
+    it "copyDirRecursive (Strict, FailEarly), destination in source" $
       copyDirRecursive' "inputDir"
                         "inputDir/foo"
+                        Strict
+                        FailEarly
         `shouldThrow`
         isDestinationInSource
 
-    it "copyDirRecursive, destination and source same directory" $
+    it "copyDirRecursive (Strict, FailEarly), destination and source same directory" $
       copyDirRecursive' "inputDir"
                         "inputDir"
+                        Strict
+                        FailEarly
         `shouldThrow`
         isSameFile
+
+

hpath-directory/test/System/Posix/RawFilePath/Directory/CopyFileOverwriteSpec.hs

@@ -1,10 +1,11 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.CopyFileOverwriteSpec where
+module System.Posix.RawFilePath.Directory.CopyFileOverwriteSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -16,8 +17,14 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+import Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileOverwriteSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -51,79 +58,91 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyFileOverwrite" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.copyFile" $ do
 
     -- successes --
-    it "copyFileOverwrite, everything clear" $ do
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), everything clear" $ do
+      copyFile' "inputFile"
                 "outputFile"
+                Overwrite
       removeFileIfExists "outputFile"
 
-    it "copyFileOverwrite, output file already exists, all clear" $ do
-      copyFile' "alreadyExists" "alreadyExists.bak"
-      copyFileOverwrite' "inputFile"
-                         "alreadyExists"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "alreadyExists")
+    it "copyFile (Overwrite), output file already exists, all clear" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "alreadyExists" "alreadyExists.bak" Strict
+      copyFile' "inputFile" "alreadyExists" Overwrite
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "alreadyExists")
         `shouldReturn` ExitSuccess
       removeFileIfExists "alreadyExists"
-      copyFile' "alreadyExists.bak" "alreadyExists"
+      copyFile' "alreadyExists.bak" "alreadyExists" Strict
       removeFileIfExists "alreadyExists.bak"
 
-    it "copyFileOverwrite, and compare" $ do
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), and compare" $ do
+      tmpDir' <- getRawTmpDir
+      copyFile' "inputFile"
                 "outputFile"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "outputFile")
+                Overwrite
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
         `shouldReturn` ExitSuccess
       removeFileIfExists "outputFile"
 
+
     -- posix failures --
-    it "copyFileOverwrite, input file does not exist" $
-      copyFileOverwrite' "noSuchFile"
+    it "copyFile (Overwrite), input file does not exist" $
+      copyFile' "noSuchFile"
                 "outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
-    it "copyFileOverwrite, no permission to write to output directory" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), no permission to write to output directory" $
+      copyFile' "inputFile"
                 "outputDirNoWrite/outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFileOverwrite, cannot open output directory" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), cannot open output directory" $
+      copyFile' "inputFile"
                 "noPerms/outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFileOverwrite, cannot open source directory" $
-      copyFileOverwrite' "noPerms/inputFile"
+    it "copyFile (Overwrite), cannot open source directory" $
+      copyFile' "noPerms/inputFile"
                 "outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFileOverwrite, wrong input type (symlink)" $
-      copyFileOverwrite' "inputFileSymL"
+    it "copyFile (Overwrite), wrong input type (symlink)" $
+      copyFile' "inputFileSymL"
                 "outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
-    it "copyFileOverwrite, wrong input type (directory)" $
-      copyFileOverwrite' "wrongInput"
+    it "copyFile (Overwrite), wrong input type (directory)" $
+      copyFile' "wrongInput"
                 "outputFile"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
-    it "copyFileOverwrite, output file already exists and is a dir" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), output file already exists and is a dir" $
+      copyFile' "inputFile"
                 "alreadyExistsD"
+                Overwrite
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     -- custom failures --
-    it "copyFileOverwrite, output and input are same file" $
-      copyFileOverwrite' "inputFile"
+    it "copyFile (Overwrite), output and input are same file" $
+      copyFile' "inputFile"
                 "inputFile"
+                Overwrite
         `shouldThrow` isSameFile

hpath-directory/test/System/Posix/RawFilePath/Directory/CopyFileSpec.hs

@@ -1,11 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 
-module HPath.IO.CopyFileSpec where
+module System.Posix.RawFilePath.Directory.CopyFileSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -17,10 +18,15 @@ import GHC.IO.Exception
 import System.Exit
 import System.Process
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+import Data.ByteString.UTF8 (toString)
 
 
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CopyFileSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
   createRegularFile' "inputFile"
@@ -51,75 +57,87 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyFile" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.copyFile" $ do
 
     -- successes --
-    it "copyFile, everything clear" $ do
+    it "copyFile (Strict), everything clear" $ do
       copyFile' "inputFile"
                 "outputFile"
+                Strict
       removeFileIfExists "outputFile"
 
-    it "copyFile, and compare" $ do
+    it "copyFile (Strict), and compare" $ do
+      tmpDir' <- getRawTmpDir
       copyFile' "inputFile"
                 "outputFile"
-      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ toString tmpDir ++ "outputFile")
+                Strict
+      (system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
+                          ++ toString tmpDir' ++ "outputFile")
         `shouldReturn` ExitSuccess
       removeFileIfExists "outputFile"
 
     -- posix failures --
-    it "copyFile, input file does not exist" $
+    it "copyFile (Strict), input file does not exist" $
       copyFile' "noSuchFile"
                 "outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
-    it "copyFile, no permission to write to output directory" $
+    it "copyFile (Strict), no permission to write to output directory" $
       copyFile' "inputFile"
                 "outputDirNoWrite/outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFile, cannot open output directory" $
+    it "copyFile (Strict), cannot open output directory" $
       copyFile' "inputFile"
                 "noPerms/outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFile, cannot open source directory" $
+    it "copyFile (Strict), cannot open source directory" $
       copyFile' "noPerms/inputFile"
                 "outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "copyFile, wrong input type (symlink)" $
+    it "copyFile (Strict), wrong input type (symlink)" $
       copyFile' "inputFileSymL"
                 "outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
-    it "copyFile, wrong input type (directory)" $
+    it "copyFile (Strict), wrong input type (directory)" $
       copyFile' "wrongInput"
                 "outputFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
-    it "copyFile, output file already exists" $
+    it "copyFile (Strict), output file already exists" $
       copyFile' "inputFile"
                 "alreadyExists"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "copyFile, output file already exists and is a dir" $
+    it "copyFile (Strict), output file already exists and is a dir" $
       copyFile' "inputFile"
                 "alreadyExistsD"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     -- custom failures --
-    it "copyFile, output and input are same file" $
+    it "copyFile (Strict), output and input are same file" $
       copyFile' "inputFile"
                 "inputFile"
+                Strict
         `shouldThrow`
         isSameFile

hpath-directory/test/System/Posix/RawFilePath/Directory/CreateDirIfMissingSpec.hs

@@ -0,0 +1,69 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module System.Posix.RawFilePath.Directory.CreateDirIfMissingSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirIfMissingSpec"
+  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 "System.Posix.RawFilePath.Directory.CreateDirIfMissing" $ do
+
+    -- successes --
+    it "createDirIfMissing, all fine" $ do
+      createDirIfMissing' "newDir"
+      removeDirIfExists "newDir"
+
+    it "createDirIfMissing, destination directory already exists" $
+      createDirIfMissing' "alreadyExists"
+
+    -- posix failures --
+    it "createDirIfMissing, parent directories do not exist" $
+      createDirIfMissing' "some/thing/dada"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
+    it "createDirIfMissing, can't write to output directory" $
+      createDirIfMissing' "noWritePerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createDirIfMissing, can't open output directory" $
+      createDirIfMissing' "noPerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)

hpath-directory/test/System/Posix/RawFilePath/Directory/CreateDirRecursiveSpec.hs

@@ -0,0 +1,83 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module System.Posix.RawFilePath.Directory.CreateDirRecursiveSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirRecursiveSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createDir' "alreadyExists"
+  createRegularFile' "alreadyExistsF"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteDir' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
+  deleteFile' "alreadyExistsF"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.createDirRecursive" $ do
+
+    -- successes --
+    it "createDirRecursive, all fine" $ do
+      createDirRecursive' "newDir"
+      deleteDir' "newDir"
+
+    it "createDirRecursive with trailing path separator, all fine" $ do
+      createDirRecursive' "newDir/foo/"
+      deleteDir' "newDir/foo"
+      deleteDir' "newDir"
+
+    it "createDirRecursive, parent directories do not exist" $ do
+      createDirRecursive' "some/thing/dada"
+      deleteDir' "some/thing/dada"
+      deleteDir' "some/thing"
+      deleteDir' "some"
+
+    it "createDirRecursive, destination directory already exists" $
+      createDirRecursive' "alreadyExists"
+
+    -- posix failures --
+    it "createDirRecursive, destination already exists and is a file" $
+      createDirRecursive' "alreadyExistsF"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "createDirRecursive, can't write to output directory" $
+      createDirRecursive' "noWritePerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "createDirRecursive, can't open output directory" $
+      createDirRecursive' "noPerms/newDir"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == PermissionDenied)
+
+
+

hpath-directory/test/System/Posix/RawFilePath/Directory/CreateDirSpec.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.CreateDirSpec where
+module System.Posix.RawFilePath.Directory.CreateDirSpec where
 
 
 import Test.Hspec
@@ -13,10 +13,14 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
 
 
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateDirSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
   createDir' "alreadyExists"
@@ -37,8 +41,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.createDir" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.createDir" $ do
 
     -- successes --
     it "createDir, all fine" $ do
@@ -46,6 +50,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
       removeDirIfExists "newDir"
 
     -- posix failures --
+    it "createDir, parent directories do not exist" $
+      createDir' "some/thing/dada"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
     it "createDir, can't write to output directory" $
       createDir' "noWritePerms/newDir"
         `shouldThrow`

hpath-directory/test/System/Posix/RawFilePath/Directory/CreateRegularFileSpec.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.CreateRegularFileSpec where
+module System.Posix.RawFilePath.Directory.CreateRegularFileSpec where
 
 
 import Test.Hspec
@@ -13,10 +13,14 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
 
 
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateRegularFileSpec"
+  createTmpDir
+
 setupFiles :: IO ()
 setupFiles = do
   createRegularFile' "alreadyExists"
@@ -25,8 +29,6 @@ setupFiles = do
   noPerms "noPerms"
   noWritableDirPerms "noWritePerms"
 
-
-
 cleanupFiles :: IO ()
 cleanupFiles = do
   normalDirPerms "noPerms"
@@ -37,8 +39,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.createRegularFile" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.createRegularFile" $ do
 
     -- successes --
     it "createRegularFile, all fine" $ do
@@ -46,6 +48,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
       removeFileIfExists "newDir"
 
     -- posix failures --
+    it "createRegularFile, parent directories do not exist" $
+      createRegularFile' "some/thing/dada"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
     it "createRegularFile, can't write to destination directory" $
       createRegularFile' "noWritePerms/newDir"
         `shouldThrow`

hpath-directory/test/System/Posix/RawFilePath/Directory/CreateSymlinkSpec.hs

@@ -1,10 +1,9 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.CreateSymlinkSpec where
+module System.Posix.RawFilePath.Directory.CreateSymlinkSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -14,8 +13,12 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "CreateSymlinkSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -37,8 +40,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.createSymlink" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.createSymlink" $ do
 
     -- successes --
     it "createSymlink, all fine" $ do
@@ -46,6 +49,11 @@ spec = before_ setupFiles $ after_ cleanupFiles $
       removeFileIfExists "newSymL"
 
     -- posix failures --
+    it "createSymlink, parent directories do not exist" $
+      createSymlink' "some/thing/dada" "lala"
+        `shouldThrow`
+        (\e -> ioeGetErrorType e == NoSuchThing)
+
     it "createSymlink, can't write to destination directory" $
       createSymlink' "noWritePerms/newDir" "lala"
         `shouldThrow`

hpath-directory/test/System/Posix/RawFilePath/Directory/DeleteDirRecursiveSpec.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.DeleteDirRecursiveSpec where
+module System.Posix.RawFilePath.Directory.DeleteDirRecursiveSpec where
 
 
 import Test.Hspec
@@ -17,8 +17,13 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirRecursiveSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -46,8 +51,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.deleteDirRecursive" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.deleteDirRecursive" $ do
 
     -- successes --
     it "deleteDirRecursive, empty directory, all fine" $ do

hpath-directory/test/System/Posix/RawFilePath/Directory/DeleteDirSpec.hs

@@ -1,6 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.DeleteDirSpec where
+module System.Posix.RawFilePath.Directory.DeleteDirSpec where
 
 
 import Test.Hspec
@@ -17,8 +17,14 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteDirSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -46,8 +52,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.deleteDir" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.deleteDir" $ do
 
     -- successes --
     it "deleteDir, empty directory, all fine" $ do

hpath-directory/test/System/Posix/RawFilePath/Directory/DeleteFileSpec.hs

@@ -1,9 +1,10 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.DeleteFileSpec where
+module System.Posix.RawFilePath.Directory.DeleteFileSpec where
 
 
 import Test.Hspec
+import "hpath-directory" System.Posix.RawFilePath.Directory
 import System.IO.Error
   (
     ioeGetErrorType
@@ -17,8 +18,12 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "DeleteFileSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -41,8 +46,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.deleteFile" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.deleteFile" $ do
 
     -- successes --
     it "deleteFile, regular file, all fine" $ do
@@ -55,6 +60,7 @@ spec = before_ setupFiles $ after_ cleanupFiles $
     it "deleteFile, symlink, all fine" $ do
       recreateSymlink' "syml"
                        "testFile"
+                       Strict
       deleteFile' "testFile"
       getSymbolicLinkStatus "testFile"
         `shouldThrow`
@@ -64,7 +70,7 @@ spec = before_ setupFiles $ after_ cleanupFiles $
     it "deleteFile, wrong file type (directory)" $
       deleteFile' "dir"
         `shouldThrow`
-        (\e -> ioeGetErrorType e == InappropriateType)
+        (\e -> ioeGetErrorType e == InappropriateType || ioeGetErrorType e == PermissionDenied)
 
     it "deleteFile, file does not exist" $
       deleteFile' "doesNotExist"

hpath-directory/test/System/Posix/RawFilePath/Directory/GetDirsFilesSpec.hs

@@ -1,38 +1,30 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.GetDirsFilesSpec where
+module System.Posix.RawFilePath.Directory.GetDirsFilesSpec where
 
 
-import Control.Applicative
-  (
-    (<$>)
-  )
 import Data.List
   (
     sort
   )
-import Data.Maybe
-  (
-    fromJust
-  )
-import qualified HPath as P
-import HPath.IO
+import "hpath-directory" System.Posix.RawFilePath.Directory hiding (getDirsFiles')
+import System.Posix.FilePath
 import Test.Hspec
 import System.IO.Error
   (
     ioeGetErrorType
   )
-import System.Posix.Env.ByteString
-  (
-    getEnv
-  )
 import GHC.IO.Exception
   (
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetDirsFilesSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -61,21 +53,21 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.getDirsFiles" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.getDirsFiles" $ do
 
     -- successes --
     it "getDirsFiles, all fine" $
       withRawTmpDir $ \p -> do
-      expectedFiles <- mapM P.parseRel [".hidden"
-                                       ,"Lala"
-                                       ,"dir"
-                                       ,"dirsym"
-                                       ,"file"
-                                       ,"noPerms"
-                                       ,"syml"]
+      let expectedFiles = [".hidden"
+                          ,"Lala"
+                          ,"dir"
+                          ,"dirsym"
+                          ,"file"
+                          ,"noPerms"
+                          ,"syml"]
       (fmap sort $ getDirsFiles p)
-        `shouldReturn` fmap (p P.</>) expectedFiles
+        `shouldReturn` fmap (p </>) expectedFiles
 
     -- posix failures --
     it "getDirsFiles, nonexistent directory" $

hpath-directory/test/System/Posix/RawFilePath/Directory/GetFileTypeSpec.hs

@@ -1,9 +1,9 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.GetFileTypeSpec where
+module System.Posix.RawFilePath.Directory.GetFileTypeSpec where
 
 
-import HPath.IO
+import "hpath-directory" System.Posix.RawFilePath.Directory
 import Test.Hspec
 import System.IO.Error
   (
@@ -14,8 +14,13 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "GetFileTypeSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -42,8 +47,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.getFileType" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.getFileType" $ do
 
     -- successes --
     it "getFileType, regular file" $

hpath-directory/test/System/Posix/RawFilePath/Directory/MoveFileOverwriteSpec.hs

@@ -0,0 +1,126 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module System.Posix.RawFilePath.Directory.MoveFileOverwriteSpec where
+
+
+import Test.Hspec
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.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 "System.Posix.RawFilePath.Directory.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`
+        (\e -> ioeGetErrorType e == AlreadyExists)
+
+    it "moveFile (Overwrite), source and dest are same file" $
+      moveFile' "myFile"
+                "myFile"
+                Overwrite
+        `shouldThrow`
+        isSameFile

hpath-directory/test/System/Posix/RawFilePath/Directory/MoveFileSpec.hs

@@ -1,10 +1,11 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.MoveFileSpec where
+module System.Posix.RawFilePath.Directory.MoveFileSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -14,8 +15,13 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "MoveFileSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -47,67 +53,77 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.moveFile" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.moveFile" $ do
 
     -- successes --
-    it "moveFile, all fine" $
+    it "moveFile (Strict), all fine" $
       moveFile' "myFile"
                 "movedFile"
+                Strict
 
-    it "moveFile, all fine" $
+    it "moveFile (Strict), all fine" $
       moveFile' "myFile"
                 "dir/movedFile"
+                Strict
 
-    it "moveFile, all fine on symlink" $
+    it "moveFile (Strict), all fine on symlink" $
       moveFile' "myFileL"
                 "movedFile"
+                Strict
 
-    it "moveFile, all fine on directory" $
+    it "moveFile (Strict), all fine on directory" $
       moveFile' "dir"
                 "movedFile"
+                Strict
 
     -- posix failures --
-    it "moveFile, source file does not exist" $
+    it "moveFile (Strict), source file does not exist" $
       moveFile' "fileDoesNotExist"
                 "movedFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
-    it "moveFile, can't write to destination directory" $
+    it "moveFile (Strict), can't write to destination directory" $
       moveFile' "myFile"
                 "noWritePerm/movedFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "moveFile, can't open destination directory" $
+    it "moveFile (Strict), can't open destination directory" $
       moveFile' "myFile"
                 "noPerms/movedFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "moveFile, can't open source directory" $
+    it "moveFile (Strict), can't open source directory" $
       moveFile' "noPerms/myFile"
                 "movedFile"
+                Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     -- custom failures --
-    it "moveFile, destination file already exists" $
+    it "moveFile (Strict), destination file already exists" $
       moveFile' "myFile"
                 "alreadyExists"
+                Strict
         `shouldThrow`
-        isFileDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "moveFile, move from file to dir" $
+    it "moveFile (Strict), move from file to dir" $
       moveFile' "myFile"
                 "alreadyExistsD"
+                Strict
         `shouldThrow`
-        isDirDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "moveFile, source and dest are same file" $
+    it "moveFile (Strict), source and dest are same file" $
       moveFile' "myFile"
                 "myFile"
+                Strict
         `shouldThrow`
         isSameFile
-

hpath-directory/test/System/Posix/RawFilePath/Directory/ReadFileSpec.hs

@@ -0,0 +1,85 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.ReadFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "ReadFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "Blahfaselgagaga"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.readFile" $ do
+
+    -- successes --
+    it "readFile (Strict) file with content, everything clear" $ do
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFile (Strict) symlink, everything clear" $ do
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "Blahfaselgagaga"
+
+    it "readFile (Strict) empty file, everything clear" $ do
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` ""
+
+
+    -- posix failures --
+    it "readFile (Strict) directory, wrong file type" $ do
+      readFile' "alreadyExistsD"
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "readFile (Strict) file, no permissions" $ do
+      readFile' "noPerms"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFile (Strict) file, no permissions on dir" $ do
+      readFile' "noPermsD/inputFile"
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "readFile (Strict) file, no such file" $ do
+      readFile' "lalala"
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)

hpath-directory/test/System/Posix/RawFilePath/Directory/RecreateSymlinkOverwriteSpec.hs

@@ -0,0 +1,139 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+module System.Posix.RawFilePath.Directory.RecreateSymlinkOverwriteSpec where
+
+
+-- TODO: exception if destination exists but is not a file + `OverWrite` CopyMode
+
+
+import Test.Hspec
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.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 "System.Posix.RawFilePath.Directory.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
+

hpath-directory/test/System/Posix/RawFilePath/Directory/RecreateSymlinkSpec.hs

@@ -1,10 +1,13 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.RecreateSymlinkSpec where
+module System.Posix.RawFilePath.Directory.RecreateSymlinkSpec where
+
+
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -14,8 +17,13 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RecreateSymlinkSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -46,67 +54,77 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.recreateSymlink" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.recreateSymlink" $ do
 
     -- successes --
-    it "recreateSymLink, all fine" $ do
+    it "recreateSymLink (Strict), all fine" $ do
       recreateSymlink' "myFileL"
                        "movedFile"
+                       Strict
       removeFileIfExists "movedFile"
 
-    it "recreateSymLink, all fine" $ do
+    it "recreateSymLink (Strict), all fine" $ do
       recreateSymlink' "myFileL"
                        "dir/movedFile"
+                       Strict
       removeFileIfExists "dir/movedFile"
 
     -- posix failures --
-    it "recreateSymLink, wrong input type (file)" $
+    it "recreateSymLink (Strict), wrong input type (file)" $
       recreateSymlink' "myFile"
                        "movedFile"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
-    it "recreateSymLink, wrong input type (directory)" $
+    it "recreateSymLink (Strict), wrong input type (directory)" $
       recreateSymlink' "dir"
                        "movedFile"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
-    it "recreateSymLink, can't write to destination directory" $
+    it "recreateSymLink (Strict), can't write to destination directory" $
       recreateSymlink' "myFileL"
                        "noWritePerm/movedFile"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "recreateSymLink, can't open destination directory" $
+    it "recreateSymLink (Strict), can't open destination directory" $
       recreateSymlink' "myFileL"
                        "noPerms/movedFile"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "recreateSymLink, can't open source directory" $
+    it "recreateSymLink (Strict), can't open source directory" $
       recreateSymlink' "noPerms/myFileL"
                        "movedFile"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
-    it "recreateSymLink, destination file already exists" $
+    it "recreateSymLink (Strict), destination file already exists" $
       recreateSymlink' "myFileL"
                        "alreadyExists"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
-    it "recreateSymLink, destination already exists and is a dir" $
+    it "recreateSymLink (Strict), destination already exists and is a dir" $
       recreateSymlink' "myFileL"
                        "alreadyExistsD"
+                       Strict
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     -- custom failures --
-    it "recreateSymLink, source and destination are the same file" $
+    it "recreateSymLink (Strict), source and destination are the same file" $
       recreateSymlink' "myFileL"
                        "myFileL"
+                       Strict
         `shouldThrow`
         isSameFile
 

hpath-directory/test/System/Posix/RawFilePath/Directory/RenameFileSpec.hs

@@ -1,10 +1,10 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-module HPath.IO.RenameFileSpec where
+module System.Posix.RawFilePath.Directory.RenameFileSpec where
 
 
 import Test.Hspec
-import HPath.IO.Errors
+import System.Posix.RawFilePath.Directory.Errors
 import System.IO.Error
   (
     ioeGetErrorType
@@ -14,8 +14,13 @@ import GHC.IO.Exception
     IOErrorType(..)
   )
 import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "RenameFileSpec"
+  createTmpDir
 
 
 setupFiles :: IO ()
@@ -46,8 +51,8 @@ cleanupFiles = do
 
 
 spec :: Spec
-spec = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.renameFile" $ do
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.renameFile" $ do
 
     -- successes --
     it "renameFile, all fine" $
@@ -96,13 +101,13 @@ spec = before_ setupFiles $ after_ cleanupFiles $
       renameFile' "myFile"
                   "alreadyExists"
         `shouldThrow`
-        isFileDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "renameFile, move from file to dir" $
       renameFile' "myFile"
                   "alreadyExistsD"
         `shouldThrow`
-        isDirDoesExist
+        (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "renameFile, source and dest are same file" $
       renameFile' "myFile"

hpath-directory/test/System/Posix/RawFilePath/Directory/ToAbsSpec.hs

@@ -0,0 +1,26 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.ToAbsSpec where
+
+
+import Test.Hspec
+import "hpath-directory" System.Posix.RawFilePath.Directory
+
+
+
+spec :: Spec
+spec = describe "System.Posix.RawFilePath.Directory.toAbs" $ do
+
+    -- successes --
+    it "toAbs returns absolute paths unchanged" $ do
+      let p1 = "/a/b/c/d"
+      to <- toAbs p1
+      p1 `shouldBe` to
+
+    it "toAbs returns even existing absolute paths unchanged" $ do
+      let p1 = "/home"
+      to <- toAbs p1
+      p1 `shouldBe` to
+
+

hpath-directory/test/System/Posix/RawFilePath/Directory/WriteFileLSpec.hs

@@ -0,0 +1,108 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.WriteFileLSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "WriteFileLSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "BLKASL"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.WriteFileL" $ do
+
+    -- successes --
+    it "WriteFileL file with content, everything clear" $ do
+      writeFileL' "fileWithContent" "blahfaselllll"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "WriteFileL file with content, everything clear" $ do
+      writeFileL' "fileWithContent" "gagagaga"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "gagagaga"
+
+    it "WriteFileL file with content, everything clear" $ do
+      writeFileL' "fileWithContent" ""
+      out <- readFile' "fileWithContent"
+      out `shouldBe` ""
+
+    it "WriteFileL file without content, everything clear" $ do
+      writeFileL' "fileWithoutContent" "blahfaselllll"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "WriteFileL, everything clear" $ do
+      writeFileL' "fileWithoutContent" "gagagaga"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "gagagaga"
+
+    it "WriteFileL symlink, everything clear" $ do
+      writeFileL' "inputFileSymL" "blahfaselllll"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "blahfaselllll"
+
+    it "WriteFileL symlink, everything clear" $ do
+      writeFileL' "inputFileSymL" "gagagaga"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "gagagaga"
+
+
+    -- posix failures --
+    it "WriteFileL to dir, inappropriate type" $ do
+      writeFileL' "alreadyExistsD" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "WriteFileL, no permissions to file" $ do
+      writeFileL' "noPerms" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "WriteFileL, no permissions to file" $ do
+      writeFileL' "noPermsD/inputFile" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "WriteFileL, file does not exist" $ do
+      writeFileL' "gaga" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)

hpath-directory/test/System/Posix/RawFilePath/Directory/WriteFileSpec.hs

@@ -0,0 +1,108 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module System.Posix.RawFilePath.Directory.WriteFileSpec where
+
+
+import Test.Hspec
+import System.IO.Error
+  (
+    ioeGetErrorType
+  )
+import GHC.IO.Exception
+  (
+    IOErrorType(..)
+  )
+import Utils
+
+
+
+upTmpDir :: IO ()
+upTmpDir = do
+  setTmpDir "WriteFileSpec"
+  createTmpDir
+
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "fileWithContent"
+  createRegularFile' "fileWithoutContent"
+  createSymlink' "inputFileSymL" "fileWithContent"
+  createDir' "alreadyExistsD"
+  createRegularFile' "noPerms"
+  noPerms "noPerms"
+  createDir' "noPermsD"
+  createRegularFile' "noPermsD/inputFile"
+  noPerms "noPermsD"
+  writeFile' "fileWithContent" "BLKASL"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "fileWithContent"
+  deleteFile' "fileWithoutContent"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  normalFilePerms "noPerms"
+  deleteFile' "noPerms"
+  normalDirPerms "noPermsD"
+  deleteFile' "noPermsD/inputFile"
+  deleteDir' "noPermsD"
+
+
+spec :: Spec
+spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
+  describe "System.Posix.RawFilePath.Directory.writeFile" $ do
+
+    -- successes --
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" "blahfaselllll"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" "gagagaga"
+      out <- readFile' "fileWithContent"
+      out `shouldBe` "gagagaga"
+
+    it "writeFile file with content, everything clear" $ do
+      writeFile' "fileWithContent" ""
+      out <- readFile' "fileWithContent"
+      out `shouldBe` ""
+
+    it "writeFile file without content, everything clear" $ do
+      writeFile' "fileWithoutContent" "blahfaselllll"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile, everything clear" $ do
+      writeFile' "fileWithoutContent" "gagagaga"
+      out <- readFile' "fileWithoutContent"
+      out `shouldBe` "gagagaga"
+
+    it "writeFile symlink, everything clear" $ do
+      writeFile' "inputFileSymL" "blahfaselllll"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "blahfaselllll"
+
+    it "writeFile symlink, everything clear" $ do
+      writeFile' "inputFileSymL" "gagagaga"
+      out <- readFile' "inputFileSymL"
+      out `shouldBe` "gagagaga"
+
+
+    -- posix failures --
+    it "writeFile to dir, inappropriate type" $ do
+      writeFile' "alreadyExistsD" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == InappropriateType)
+
+    it "writeFile, no permissions to file" $ do
+      writeFile' "noPerms" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "writeFile, no permissions to file" $ do
+      writeFile' "noPermsD/inputFile" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == PermissionDenied)
+
+    it "writeFile, file does not exist" $ do
+      writeFile' "gaga" ""
+        `shouldThrow` (\e -> ioeGetErrorType e == NoSuchThing)

hpath-directory/test/Utils.hs

@@ -0,0 +1,293 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+
+module Utils where
+
+
+import Control.Applicative
+  (
+    (<$>)
+  )
+import Control.Monad
+  (
+    forM_
+  , void
+  )
+import Control.Monad.IfElse
+  (
+    whenM
+  )
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Lazy as BSL
+import Data.IORef
+  (
+    newIORef
+  , readIORef
+  , writeIORef
+  , IORef
+  )
+import "hpath-directory" System.Posix.RawFilePath.Directory
+import Prelude hiding (appendFile, readFile, writeFile)
+import Data.Maybe
+  (
+    fromJust
+  )
+import System.IO.Unsafe
+  (
+    unsafePerformIO
+  )
+import qualified System.Posix.RawFilePath.Directory.Traversals as DT
+import Data.ByteString
+  (
+    ByteString
+  )
+import qualified Data.ByteString.Lazy as L
+import System.Posix.FilePath
+import System.Posix.Files.ByteString
+  (
+    groupExecuteMode
+  , groupReadMode
+  , nullFileMode
+  , otherExecuteMode
+  , otherReadMode
+  , ownerExecuteMode
+  , ownerReadMode
+  , setFileMode
+  , unionFileModes
+  )
+
+baseTmpDir :: IORef (Maybe ByteString)
+{-# NOINLINE baseTmpDir #-}
+baseTmpDir = unsafePerformIO (newIORef Nothing)
+
+
+tmpDir :: IORef (Maybe ByteString)
+{-# NOINLINE tmpDir #-}
+tmpDir = unsafePerformIO (newIORef Nothing)
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+setTmpDir :: ByteString -> IO ()
+{-# NOINLINE setTmpDir #-}
+setTmpDir bs = do
+  tmp <- fromJust <$> readIORef baseTmpDir
+  writeIORef tmpDir (Just (tmp `BS.append` bs))
+
+
+createTmpDir :: IO ()
+{-# NOINLINE createTmpDir #-}
+createTmpDir = do
+  tmp <- fromJust <$> readIORef tmpDir
+  void $ createDir newDirPerms tmp
+
+
+deleteTmpDir :: IO ()
+{-# NOINLINE deleteTmpDir #-}
+deleteTmpDir = do
+  tmp <- fromJust <$> readIORef tmpDir
+  void $ deleteDir tmp
+
+
+deleteBaseTmpDir :: IO ()
+{-# NOINLINE deleteBaseTmpDir #-}
+deleteBaseTmpDir = do
+  tmp <- fromJust <$> readIORef baseTmpDir
+  contents <- getDirsFiles tmp
+  forM_ contents deleteDir
+  void $ deleteDir tmp
+
+
+withRawTmpDir :: (ByteString -> IO a) -> IO a
+{-# NOINLINE withRawTmpDir #-}
+withRawTmpDir f = do
+  tmp <- fromJust <$> readIORef tmpDir
+  f tmp
+
+
+getRawTmpDir :: IO ByteString
+{-# NOINLINE getRawTmpDir #-}
+getRawTmpDir = withRawTmpDir (return . flip BS.append "/")
+
+
+withTmpDir :: ByteString -> (ByteString -> IO a) -> IO a
+{-# NOINLINE withTmpDir #-}
+withTmpDir ip f = do
+  tmp <- fromJust <$> readIORef tmpDir
+  let p = tmp </> ip
+  f p
+
+
+withTmpDir' :: ByteString
+            -> ByteString
+            -> (ByteString -> ByteString -> IO a)
+            -> IO a
+{-# NOINLINE withTmpDir' #-}
+withTmpDir' ip1 ip2 f = do
+  tmp <- fromJust <$> readIORef tmpDir
+  let p1 = tmp </> ip1
+  let p2 = tmp </> 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)
+
+createDirIfMissing' :: ByteString -> IO ()
+{-# NOINLINE createDirIfMissing' #-}
+createDirIfMissing' dest = withTmpDir dest (createDirIfMissing newDirPerms)
+
+createDirRecursive' :: ByteString -> IO ()
+{-# NOINLINE createDirRecursive' #-}
+createDirRecursive' dest = withTmpDir dest (createDirRecursive 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 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 nullFileMode
+
+
+normalDirPerms :: ByteString -> IO ()
+{-# NOINLINE normalDirPerms #-}
+normalDirPerms path =
+  withTmpDir path $ \p -> setFileMode p newDirPerms
+
+
+normalFilePerms :: ByteString -> IO ()
+{-# NOINLINE normalFilePerms #-}
+normalFilePerms path =
+  withTmpDir path $ \p -> setFileMode p newFilePerms
+
+
+getFileType' :: ByteString -> IO FileType
+{-# NOINLINE getFileType' #-}
+getFileType' path = withTmpDir path getFileType
+
+
+getDirsFiles' :: ByteString -> IO [ByteString]
+{-# 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 ByteString
+{-# NOINLINE canonicalizePath' #-}
+canonicalizePath' p = withTmpDir p canonicalizePath
+
+
+writeFile' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE writeFile' #-}
+writeFile' ip bs =
+  withTmpDir ip $ \p -> writeFile p Nothing bs
+
+writeFileL' :: ByteString -> BSL.ByteString -> IO ()
+{-# NOINLINE writeFileL' #-}
+writeFileL' ip bs =
+  withTmpDir ip $ \p -> writeFileL p Nothing bs
+
+
+appendFile' :: ByteString -> ByteString -> IO ()
+{-# NOINLINE appendFile' #-}
+appendFile' ip bs =
+  withTmpDir ip $ \p -> appendFile p bs
+
+
+allDirectoryContents' :: ByteString -> IO [ByteString]
+{-# NOINLINE allDirectoryContents' #-}
+allDirectoryContents' ip =
+  withTmpDir ip $ \p -> DT.allDirectoryContents' p
+
+
+readFile' :: ByteString -> IO ByteString
+{-# NOINLINE readFile' #-}
+readFile' p = withTmpDir p (fmap L.toStrict . readFile)
+

hpath-filepath/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Revision history for hpath-filepath
+
+## 0.10.4 -- 2020-01-26
+
+* Add `takeAllParents`
+
+
+## 0.10.2 -- 2020-01-18
+
+* Add `isSpecialDirectoryEntry`
+
+## 0.10.0 -- 2020-01-04
+
+* First version. Split from 'hpath', contains only the filepath ByteString manipulation parts.

hpath-filepath/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2020, 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
+      notice, this list of conditions and the following disclaimer.
+
+    * 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 Julian Ospald nor the names of other
+      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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER 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.

hpath-filepath/README.md

@@ -0,0 +1,29 @@
+# HPath-filepath
+
+[![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-filepath.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-filepath) [![Build Status](https://api.travis-ci.org/hasufell/hpath.png?branch=master)](http://travis-ci.org/hasufell/hpath) [![Hackage-Deps](https://img.shields.io/hackage-deps/v/hpath-filepath.svg)](http://packdeps.haskellers.com/feed?needle=hpath-filepath)
+
+Support for bytestring based filepath manipulation, similar to 'filepath'.
+
+This package is part of the HPath suite, also check out:
+
+* [hpath](https://hackage.haskell.org/package/hpath)
+* [hpath-directory](https://hackage.haskell.org/package/hpath-directory)
+* [hpath-io](https://hackage.haskell.org/package/hpath-io)
+
+## Motivation
+
+This is basically a fork of [posix-paths](https://github.com/JohnLato/posix-paths), which seemed to have stalled development.
+
+There is also a similar library [filepath-bytestring](https://hackage.haskell.org/package/filepath-bytestring), but it doesn't follow an open development model and is cross-platform, which this library is not interested in.
+
+## Differences to 'posix-paths'
+
+* uses the `word8` package for save word8 literals instead of `OverloadedStrings`
+* `hasTrailingPathSeparator` and `dropTrailingPathSeparator` behave in the same way as their `System.FilePath` counterpart
+* has some additional functions
+
+## Differences to 'filepath-bytestring'
+
+* uses the `word8` package for save word8 literals instead of `OverloadedStrings`
+* is not cross-platform (less odd code to maintain)
+* has some additional functions

hpath-filepath/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

hpath-filepath/hpath-filepath.cabal

@@ -0,0 +1,39 @@
+name:                hpath-filepath
+version:             0.10.4
+synopsis:            ByteString based filepath manipulation
+description:         ByteString based filepath manipulation, similar to 'filepath' package. This is POSIX only.
+-- bug-reports:
+license:             BSD3
+license-file:        LICENSE
+author:              Julian Ospald <hasufell@posteo.de>
+maintainer:          Julian Ospald <hasufell@posteo.de>
+copyright:           Julian Ospald 2016
+category:            Filesystem
+build-type:          Simple
+cabal-version:       1.14
+tested-with:         GHC==7.10.3
+                   , GHC==8.0.2
+                   , GHC==8.2.2
+                   , GHC==8.4.4
+                   , GHC==8.6.5
+                   , GHC==8.8.1
+extra-source-files:  README.md
+                     CHANGELOG.md
+
+library
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  exposed-modules:     System.Posix.FilePath
+  -- other-modules:
+  -- other-extensions:
+  build-depends:       base >=4.8 && <5
+                     , bytestring >= 0.10.0.0
+                     , unix >= 2.5
+                     , word8
+  hs-source-dirs:      src
+  default-language:    Haskell2010
+
+source-repository head
+  type:     git
+  location: https://github.com/hasufell/hpath

hpath-filepath/run-doctests.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -e
+
+if [ -n "${SKIP_DOCTESTS}" ] ; then
+    echo "Skipping doctests"
+    exit 0
+fi
+
+if ! command -v doctest >/dev/null ; then
+    tempdir="$(mktemp -d)"
+    (
+     cd "${tempdir}"
+     cabal install --installdir="${tempdir}" doctest
+    )
+    export PATH="${tempdir}:$PATH"
+fi
+
+set -x
+
+cd "$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)"
+
+cabal exec doctest -- -isrc -XOverloadedStrings System.Posix.FilePath

hpath-filepath/src/System/Posix/FilePath.hs

@@ -59,6 +59,7 @@ module System.Posix.FilePath (
 , splitPath
 , joinPath
 , splitDirectories
+, takeAllParents
 
   -- * Trailing slash functions
 , hasTrailingPathSeparator
@@ -73,6 +74,7 @@ module System.Posix.FilePath (
 , isAbsolute
 , isValid
 , makeValid
+, isSpecialDirectoryEntry
 , isFileName
 , hasParentDir
 , hiddenFile
@@ -96,6 +98,7 @@ import           Control.Arrow (second)
 -- $setup
 -- >>> import Data.Char
 -- >>> import Data.Maybe
+-- >>> import Data.Word8
 -- >>> import Test.QuickCheck
 -- >>> import Control.Applicative
 -- >>> import qualified Data.ByteString as BS
@@ -484,6 +487,8 @@ joinPath = foldr (</>) BS.empty
 --
 -- >>> splitDirectories "/path/to/file.txt"
 -- ["/","path","to","file.txt"]
+-- >>> splitDirectories "path/to/file.txt"
+-- ["path","to","file.txt"]
 -- >>> splitDirectories ""
 -- []
 splitDirectories :: RawFilePath -> [RawFilePath]
@@ -496,6 +501,21 @@ splitDirectories x
     splitter = filter (not . BS.null) . BS.split pathSeparator
 
 
+-- |Get all parents of a path.
+--
+-- >>> takeAllParents "/abs/def/dod"
+-- ["/abs/def","/abs","/"]
+-- >>> takeAllParents "/foo"
+-- ["/"]
+-- >>> takeAllParents "/"
+-- []
+takeAllParents :: RawFilePath -> [RawFilePath]
+takeAllParents p
+  | np == BS.singleton pathSeparator = []
+  | otherwise = takeDirectory np : takeAllParents (takeDirectory np)
+  where
+    np = normalise p
+
 
 ------------------------
 -- Trailing slash functions
@@ -723,6 +743,22 @@ makeValid path
   | otherwise    = BS.map (\x -> if x == _nul then _underscore else x) path
 
 
+-- | Whether the filename is a special directory entry
+-- (. and ..). Does not normalise filepaths.
+--
+-- >>> isSpecialDirectoryEntry "."
+-- True
+-- >>> isSpecialDirectoryEntry ".."
+-- True
+-- >>> isSpecialDirectoryEntry "/random_ path:*"
+-- False
+isSpecialDirectoryEntry :: RawFilePath -> Bool
+isSpecialDirectoryEntry filepath
+  | BS.pack [_period, _period] == filepath = True
+  | BS.pack [_period] == filepath          = True
+  | otherwise                              = False
+
+
 -- | Is the given path a valid filename? This includes
 -- "." and "..".
 --

hpath-io/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Revision history for hpath-io
+
+## 0.13.2 -- 2020-05-08
+
+* Add getDirsFilesStream and use streamly-posix for dircontents (#34)
+
+## 0.13.0 -- 2020-01-26
+
+* switch to using 'hpath-bytestring' for the implementation (this is now just a wrapper module, mostly)
+
+## 0.12.0 -- 2020-01-20
+
+* breaking API changes
+	* RelC and Fn were removed from `hpath`
+	* further changes to `parseAny`
+
+
+## 0.11.0 -- 2020-01-18
+
+* `writeFile` not allows to set file mode and create file if it does not exist (this broke API)
+* added various new functions:
+	* createDirIfMissing
+	* writeFileL (for lazy bytestring)
+	* isReadable
+	* isExecutable
+	* getModificationTime
+	* setModificationTime
+	* setModificationTimeHiRes
+	* getDirsFiles' (returns filenames instead of paths)
+	* withRawFilePath
+	* withHandle
+
+## 0.10.1 -- 2020-01-13
+
+* Move file check functions to HPath.IO
+* Add 'doesExist'
+* Exception handling of `doesExist`, `doesFileExist`, `doesDirectoryExist` has changed: only eNOENT is catched
+* Exception handling of `isWritable` has changed: just a wrapper around `access` now
+* switch exception handling to `safe-exceptions`
+* Redo file reading API (readFileEOF dropped and now using streamly under the hood, added `readFileStream`)
+
+
+## 0.10.0 -- 2020-01-04
+
+* First version. Split from 'hpath', contains only the IO parts.
+* Now uses streamly for 'copyFile'
+* Fixed tmpdir in hspec

hpath-io/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2020, 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
+      notice, this list of conditions and the following disclaimer.
+
+    * 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 Julian Ospald nor the names of other
+      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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER 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.

hpath-io/README.md

@@ -0,0 +1,27 @@
+# HPath-IO
+
+[![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-io.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-io) [![Build Status](https://api.travis-ci.org/hasufell/hpath.png?branch=master)](http://travis-ci.org/hasufell/hpath) [![Hackage-Deps](https://img.shields.io/hackage-deps/v/hpath-io.svg)](http://packdeps.haskellers.com/feed?needle=hpath-io)
+
+High-level IO operations on files/directories, utilizing type-safe Paths. This uses [hpath-directory](https://hackage.haskell.org/package/hpath-directory) under the hood.
+
+This package is part of the HPath suite, also check out:
+
+* [hpath](https://hackage.haskell.org/package/hpath)
+* [hpath-directory](https://hackage.haskell.org/package/hpath-directory)
+* [hpath-filepath](https://hackage.haskell.org/package/hpath-filepath)
+
+## Motivation
+
+The motivation came during development of
+[hsfm](https://github.com/hasufell/hsfm)
+in order to have a proper high-level API of file related operations,
+while utilizing type-safe Paths.
+
+## Goals
+
+* high-level API to file operations like recursive directory copy
+* still allowing sufficient control to interact with the underlying low-level calls
+* unit-testing exceptions (because yes, people may rely on them)
+
+Note: this library was written for __posix__ systems and it will probably not support other systems.
+

hpath-io/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

hpath-io/TODO.md

@@ -0,0 +1,6 @@
+# TODO
+
+## Tests
+
+* `doesExist` not tested
+* `readFileStream` only implicitly tested by `readFile`

hpath-io/hpath-io.cabal

@@ -0,0 +1,46 @@
+name:                hpath-io
+version:             0.13.2
+synopsis:            High-level IO operations on files/directories
+description:         High-level IO operations on files/directories, utilizing type-safe Paths
+-- bug-reports:
+license:             BSD3
+license-file:        LICENSE
+author:              Julian Ospald <hasufell@posteo.de>
+maintainer:          Julian Ospald <hasufell@posteo.de>
+copyright:           Julian Ospald 2016
+category:            Filesystem
+build-type:          Simple
+cabal-version:       1.14
+tested-with:         GHC==7.10.3
+                   , GHC==8.0.2
+                   , GHC==8.2.2
+                   , GHC==8.4.4
+                   , GHC==8.6.5
+                   , GHC==8.8.1
+extra-source-files:  README.md
+                     CHANGELOG.md
+
+library
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  exposed-modules:   HPath.IO
+  build-depends:     base >= 4.8 && <5
+                   , bytestring >= 0.10.0.0
+                   , exceptions
+                   , hpath >= 0.11 && < 0.12
+                   , hpath-directory >= 0.13 && < 0.14
+                   , hpath-posix     >= 0.13 && < 0.14
+                   , safe-exceptions >= 0.1
+                   , streamly >= 0.7
+                   , time >= 1.8
+                   , unix >= 2.5
+  if !impl(ghc>=7.11)
+    build-depends:     transformers
+  hs-source-dirs:      src
+  default-language:    Haskell2010
+
+
+source-repository head
+  type:     git
+  location: https://github.com/hasufell/hpath

hpath-io/src/HPath/IO.hs

@@ -0,0 +1,865 @@
+-- |
+-- 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 x/ which
+-- guarantees us well-typed paths. This is a thin wrapper over
+-- System.Posix.RawFilePath.Directory in 'hpath-directory'. It's
+-- encouraged to use this module.
+--
+-- 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 FlexibleContexts #-} -- streamly
+{-# LANGUAGE PackageImports   #-}
+
+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
+  , createDirIfMissing
+  , createDirRecursive
+  , createSymlink
+  -- * File renaming/moving
+  , renameFile
+  , moveFile
+  -- * File reading
+  , readFile
+  , readFileStream
+  -- * File writing
+  , writeFile
+  , writeFileL
+  , appendFile
+  -- * File permissions
+  , RD.newFilePerms
+  , RD.newDirPerms
+  -- * File checks
+  , doesExist
+  , doesFileExist
+  , doesDirectoryExist
+  , isReadable
+  , isWritable
+  , isExecutable
+  , canOpenDirectory
+  -- * File times
+  , getModificationTime
+  , setModificationTime
+  , setModificationTimeHiRes
+  -- * Directory reading
+  , getDirsFiles
+  , getDirsFiles'
+  , getDirsFilesStream
+  -- * Filetype operations
+  , getFileType
+  -- * Others
+  , canonicalizePath
+  , toAbs
+  , withRawFilePath
+  , withHandle
+  , module System.Posix.RawFilePath.Directory.Errors
+  )
+where
+
+
+import           Control.Exception.Safe         ( MonadMask
+                                                , MonadCatch
+                                                , bracketOnError
+                                                , finally
+                                                )
+import           Control.Monad.Catch            ( MonadThrow(..) )
+
+import           Data.ByteString                ( ByteString )
+import           Data.Traversable               ( for )
+import qualified Data.ByteString.Lazy          as L
+import           Data.Time.Clock
+import           Data.Time.Clock.POSIX          ( POSIXTime )
+import           HPath
+import           Prelude                 hiding ( appendFile
+                                                , readFile
+                                                , writeFile
+                                                )
+import           Streamly
+import qualified System.IO                     as SIO
+import           System.Posix.Directory.ByteString
+                                                ( getWorkingDirectory )
+import qualified "unix" System.Posix.IO.ByteString
+                                               as SPI
+import           System.Posix.FD                ( openFd )
+import           System.Posix.RawFilePath.Directory.Errors
+import           System.Posix.Types             ( FileMode
+                                                , ProcessID
+                                                , EpochTime
+                                                )
+import qualified System.Posix.RawFilePath.Directory
+                                               as RD
+import           System.Posix.RawFilePath.Directory
+                                                ( FileType
+                                                , RecursiveErrorMode
+                                                , CopyMode
+                                                )
+
+
+
+
+
+
+    --------------------
+    --[ File Copying ]--
+    --------------------
+
+
+
+-- |Copies the contents of a directory recursively to the given destination, while preserving permissions.
+-- Does not follow symbolic links. This behaves more or less like
+-- the following, without descending into the destination if it
+-- already exists:
+--
+-- @
+--   cp -a \/source\/dir \/destination\/somedir
+-- @
+--
+-- For directory contents, this will ignore any file type that is not
+-- `RegularFile`, `SymbolicLink` or `Directory`.
+--
+-- For `Overwrite` copy mode this does not prune destination directory
+-- contents, so the destination might contain more files than the source after
+-- the operation has completed. Permissions of existing directories are
+-- fixed.
+--
+-- Safety/reliability concerns:
+--
+--    * 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
+--
+-- Note: may call `getcwd` (only if destination is a relative path)
+copyDirRecursive :: Path b1  -- ^ source dir
+                 -> Path b2  -- ^ destination (parent dirs
+                             --   are not automatically created)
+                 -> CopyMode
+                 -> RecursiveErrorMode
+                 -> IO ()
+copyDirRecursive (Path fromp) (Path destdirp) cm rm =
+  RD.copyDirRecursive fromp destdirp cm rm
+
+
+-- |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 already exists
+--
+-- Throws in `Overwrite` mode only:
+--
+--    - `UnsatisfiedConstraints` if destination file is non-empty directory
+--
+-- Notes:
+--
+--    - calls `symlink`
+--    - calls `getcwd` in Overwrite mode (if destination is a relative path)
+recreateSymlink :: Path b1   -- ^ the old symlink file
+                -> Path b2   -- ^ destination file
+                -> CopyMode
+                -> IO ()
+recreateSymlink (Path symsourceBS) (Path newsymBS) cm =
+  RD.recreateSymlink symsourceBS newsymBS cm
+
+
+-- |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.
+-- In `Strict` mode the destination file must not exist.
+--
+-- 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
+--
+-- Notes:
+--
+--    - may call `getcwd` in Overwrite mode (if destination is a relative path)
+copyFile :: Path b1   -- ^ source file
+         -> Path b2   -- ^ destination file
+         -> CopyMode
+         -> IO ()
+copyFile (Path from) (Path to) cm = RD.copyFile from to cm
+
+-- |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
+--
+-- Note: may call `getcwd` in Overwrite mode (if destination is a relative path)
+easyCopy :: Path b1 -> Path b2 -> CopyMode -> RecursiveErrorMode -> IO ()
+easyCopy (Path from) (Path to) cm rm = RD.easyCopy from to cm rm
+
+
+
+
+
+
+    ---------------------
+    --[ 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 b -> IO ()
+deleteFile (Path p) = RD.deleteFile p
+
+
+-- |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 b -> IO ()
+deleteDir (Path p) = RD.deleteDir p
+
+
+-- |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 b -> IO ()
+deleteDirRecursive (Path p) = RD.deleteDirRecursive 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 b -> IO ()
+easyDelete (Path p) = RD.easyDelete p
+
+
+
+
+    --------------------
+    --[ File Opening ]--
+    --------------------
+
+
+-- |Opens a file appropriately by invoking xdg-open. The file type
+-- is not checked. This forks a process.
+openFile :: Path b -> IO ProcessID
+openFile (Path fp) = RD.openFile fp
+
+
+-- |Executes a program with the given arguments. This forks a process.
+executeFile :: Path b          -- ^ program
+            -> [ByteString]    -- ^ arguments
+            -> IO ProcessID
+executeFile (Path fp) args = RD.executeFile fp args
+
+
+
+
+    ---------------------
+    --[ 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 already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+createRegularFile :: FileMode -> Path b -> IO ()
+createRegularFile fm (Path destBS) = RD.createRegularFile fm destBS
+
+
+-- |Create an empty directory at the given directory with the given filename.
+--
+-- Throws:
+--
+--    - `PermissionDenied` if output directory cannot be written to
+--    - `AlreadyExists` if destination already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+createDir :: FileMode -> Path b -> IO ()
+createDir fm (Path destBS) = RD.createDir fm destBS
+
+-- |Create an empty directory at the given directory with the given filename.
+--
+-- Throws:
+--
+--    - `PermissionDenied` if output directory cannot be written to
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+createDirIfMissing :: FileMode -> Path b -> IO ()
+createDirIfMissing fm (Path destBS) = RD.createDirIfMissing fm destBS
+
+
+-- |Create an empty directory at the given directory with the given filename.
+-- All parent directories are created with the same filemode. This
+-- basically behaves like:
+--
+-- @
+--   mkdir -p \/some\/dir
+-- @
+--
+-- Safety/reliability concerns:
+--
+--    * not atomic
+--
+-- Throws:
+--
+--    - `PermissionDenied` if any part of the path components do not
+--      exist and cannot be written to
+--    - `AlreadyExists` if destination already exists and
+--      is *not* a directory
+--
+-- Note: calls `getcwd` if the input path is a relative path
+createDirRecursive :: FileMode -> Path b -> IO ()
+createDirRecursive fm (Path p) = RD.createDirRecursive fm p
+
+
+
+-- |Create a symlink.
+--
+-- Throws:
+--
+--    - `PermissionDenied` if output directory cannot be written to
+--    - `AlreadyExists` if destination file already exists
+--    - `NoSuchThing` if any of the parent components of the path
+--      do not exist
+--
+-- Note: calls `symlink`
+createSymlink :: Path b     -- ^ destination file
+              -> ByteString -- ^ path the symlink points to
+              -> IO ()
+createSymlink (Path destBS) sympoint = RD.createSymlink destBS sympoint
+
+
+
+    ----------------------------
+    --[ 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
+--     - `AlreadyExists` if destination already exists
+--     - `SameFile` if destination and source are the same file
+--       (`HPathIOException`)
+--
+-- Note: calls `rename` (but does not allow to rename over existing files)
+renameFile :: Path b1 -> Path b2 -> IO ()
+renameFile (Path from) (Path to) = RD.renameFile from to
+
+
+
+-- |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:
+--
+--    - `AlreadyExists` if destination already exists
+--
+-- Notes:
+--
+--    - calls `rename` (but does not allow to rename over existing files)
+--    - calls `getcwd` in Overwrite mode if destination is a relative path
+moveFile :: Path b1   -- ^ file to move
+         -> Path b2   -- ^ destination
+         -> CopyMode
+         -> IO ()
+moveFile (Path from) (Path to) cm = RD.moveFile from to cm
+
+
+
+
+
+    --------------------
+    --[ File Reading ]--
+    --------------------
+
+
+-- |Read the given file *at once* into memory as a lazy ByteString.
+-- Symbolic links are followed, no sanity checks on file size
+-- or file type. File must exist. Uses Builders under the hood
+-- (hence lazy ByteString).
+--
+-- Safety/reliability concerns:
+--
+--    * the whole file is read into memory, this doesn't read lazily
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+readFile :: Path b -> IO L.ByteString
+readFile (Path path) = RD.readFile path
+
+
+
+-- | Open the given file as a filestream. Once the filestream is
+-- exits, the filehandle is cleaned up.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+readFileStream :: Path b -> IO (SerialT IO ByteString)
+readFileStream (Path fp) = RD.readFileStream fp
+
+
+
+
+    --------------------
+    --[ File Writing ]--
+    --------------------
+
+
+-- |Write a given ByteString to a file, truncating the file beforehand.
+-- Follows symlinks.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+writeFile :: Path b
+          -> Maybe FileMode  -- ^ if Nothing, file must exist
+          -> ByteString
+          -> IO ()
+writeFile (Path fp) fmode bs = RD.writeFile fp fmode bs
+
+
+-- |Write a given lazy ByteString to a file, truncating the file beforehand.
+-- Follows symlinks.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+--
+-- Note: uses streamly under the hood
+writeFileL :: Path b
+           -> Maybe FileMode  -- ^ if Nothing, file must exist
+           -> L.ByteString
+           -> IO ()
+writeFileL (Path fp) fmode lbs = RD.writeFileL fp fmode lbs
+
+
+-- |Append a given ByteString to a file.
+-- The file must exist. Follows symlinks.
+--
+-- Throws:
+--
+--     - `InappropriateType` if file is not a regular file or a symlink
+--     - `PermissionDenied` if we cannot read the file or the directory
+--        containting it
+--     - `NoSuchThing` if the file does not exist
+appendFile :: Path b -> ByteString -> IO ()
+appendFile (Path fp) bs = RD.appendFile fp bs
+
+
+
+
+
+    -------------------
+    --[ File checks ]--
+    -------------------
+
+
+-- |Checks if the given file exists.
+-- Does not follow symlinks.
+--
+-- Only eNOENT is catched (and returns False).
+doesExist :: Path b -> IO Bool
+doesExist (Path bs) = RD.doesExist bs
+
+
+-- |Checks if the given file exists and is not a directory.
+-- Does not follow symlinks.
+--
+-- Only eNOENT is catched (and returns False).
+doesFileExist :: Path b -> IO Bool
+doesFileExist (Path bs) = RD.doesFileExist bs
+
+
+-- |Checks if the given file exists and is a directory.
+-- Does not follow symlinks.
+--
+-- Only eNOENT is catched (and returns False).
+doesDirectoryExist :: Path b -> IO Bool
+doesDirectoryExist (Path bs) = RD.doesDirectoryExist bs
+
+
+-- |Checks whether a file or folder is readable.
+--
+-- Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
+--
+-- Throws:
+--
+--     - `NoSuchThing` if the file does not exist
+isReadable :: Path b -> IO Bool
+isReadable (Path bs) = RD.isReadable bs
+
+-- |Checks whether a file or folder is writable.
+--
+-- Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
+--
+-- Throws:
+--
+--     - `NoSuchThing` if the file does not exist
+isWritable :: Path b -> IO Bool
+isWritable (Path bs) = RD.isWritable bs
+
+
+-- |Checks whether a file or folder is executable.
+--
+-- Only eACCES, eROFS, eTXTBSY, ePERM are catched (and return False).
+--
+-- Throws:
+--
+--     - `NoSuchThing` if the file does not exist
+isExecutable :: Path b -> IO Bool
+isExecutable (Path bs) = RD.isExecutable bs
+
+
+
+-- |Checks whether the directory at the given path exists and can be
+-- opened. This invokes `openDirStream` which follows symlinks.
+canOpenDirectory :: Path b -> IO Bool
+canOpenDirectory (Path bs) = RD.canOpenDirectory bs
+
+
+
+
+    ------------------
+    --[ File times ]--
+    ------------------
+
+
+getModificationTime :: Path b -> IO UTCTime
+getModificationTime (Path bs) = RD.getModificationTime bs
+
+setModificationTime :: Path b -> EpochTime -> IO ()
+setModificationTime (Path bs) t = RD.setModificationTime bs t
+
+setModificationTimeHiRes :: Path b -> POSIXTime -> IO ()
+setModificationTimeHiRes (Path bs) t = RD.setModificationTimeHiRes bs t
+
+
+
+    -------------------------
+    --[ 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
+--     - `PathParseException` if a filename could not be parsed (should never happen)
+getDirsFiles :: Path b        -- ^ dir to read
+             -> IO [Path b]
+getDirsFiles p = do
+  contents <- getDirsFiles' p
+  pure $ fmap (p </>) contents
+
+
+-- | Like 'getDirsFiles', but returns the filename only, instead
+-- of prepending the base path.
+getDirsFiles' :: Path b        -- ^ dir to read
+              -> IO [Path Rel]
+getDirsFiles' (Path fp) = do
+  rawContents <- RD.getDirsFiles' fp
+  for rawContents $ \r -> parseRel r
+
+
+-- | Like 'getDirsFiles'', except returning a Stream.
+getDirsFilesStream :: (MonadCatch m, MonadAsync m, MonadMask m)
+                   => Path b
+                   -> IO (SerialT m (Path Rel))
+getDirsFilesStream (Path fp) = do
+  s <- RD.getDirsFilesStream fp
+  pure (s >>= parseRel)
+
+
+
+
+    ---------------------------
+    --[ 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 b -> IO FileType
+getFileType (Path fp) = RD.getFileType fp
+
+
+
+    --------------
+    --[ Others ]--
+    --------------
+
+
+
+-- |Applies `realpath` on the given path.
+--
+-- Throws:
+--
+--    - `NoSuchThing` if the file at the given path does not exist
+--    - `NoSuchThing` if the symlink is broken
+--    - `PathParseException` if realpath does not return an absolute path
+canonicalizePath :: Path b -> IO (Path Abs)
+canonicalizePath (Path l) = do
+  nl <- RD.canonicalizePath l
+  parseAbs nl
+
+
+-- |Converts any path to an absolute path.
+-- This is done in the following way:
+--
+--    - if the path is already an absolute one, just return it
+--    - if it's a relative path, prepend the current directory to it
+toAbs :: Path b -> IO (Path Abs)
+toAbs (Path bs) = do
+  let mabs = parseAbs bs :: Maybe (Path Abs)
+  case mabs of
+    Just a  -> return a
+    Nothing -> do
+      cwd <- getWorkingDirectory >>= parseAbs
+      r   <- parseRel bs -- we know it must be relative now
+      return $ cwd </> r
+
+
+-- | Helper function to use the Path library without
+-- buying into the Path type too much. This uses 'parseAny'
+-- under the hood and may throw `PathParseException`.
+--
+-- Throws:
+--
+--    - `PathParseException` if the bytestring could neither be parsed as
+--      relative or absolute Path
+withRawFilePath :: MonadThrow m
+                => ByteString
+                -> (Either (Path Abs) (Path Rel) -> m b)
+                -> m b
+withRawFilePath bs action = do
+  path <- parseAny bs
+  action path
+
+
+-- | Convenience function to open the path as a handle.
+--
+-- If the file does not exist, it will be created with 'newFilePerms'.
+--
+-- Throws:
+--
+--    - `PathParseException` if the bytestring could neither be parsed as
+--      relative or absolute Path
+withHandle :: ByteString
+           -> SPI.OpenMode
+           -> ((SIO.Handle, Either (Path Abs) (Path Rel)) -> IO a)
+           -> IO a
+withHandle bs mode action = do
+  path   <- parseAny bs
+  handle <-
+    bracketOnError (openFd bs mode [] (Just RD.newFilePerms)) (SPI.closeFd)
+      $ SPI.fdToHandle
+  finally (action (handle, path)) (SIO.hClose handle)

hpath-posix/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Revision history for hpath-posix
+
+## 0.13.2 -- 2020-04-14
+
+* fix macOS compatibility, especially with memory bug in `fdopendir`
+
+## 0.13.1 -- 2020-02-08
+
+* Remove unnecessary dependencies
+
+
+## 0.13.0 -- 2020-01-29
+
+* First version. Released on an unsuspecting world.

hpath-posix/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2020, 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
+      notice, this list of conditions and the following disclaimer.
+
+    * 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 Julian Ospald nor the names of other
+      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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER 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.

hpath-posix/README.md

@@ -0,0 +1,13 @@
+# HPath-filepath
+
+[![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-posix.svg?label=Hackage)](https://hackage.haskell.org/package/hpath-posix) [![Build Status](https://api.travis-ci.org/hasufell/hpath.png?branch=master)](http://travis-ci.org/hasufell/hpath) [![Hackage-Deps](https://img.shields.io/hackage-deps/v/hpath-posix.svg)](http://packdeps.haskellers.com/feed?needle=hpath-posix)
+
+Some low-level POSIX glue code, that is not in 'unix'.
+
+This package is part of the HPath suite, also check out:
+
+* [hpath](https://hackage.haskell.org/package/hpath)
+* [hpath-directory](https://hackage.haskell.org/package/hpath-directory)
+* [hpath-filepath](https://hackage.haskell.org/package/hpath-filepath)
+* [hpath-io](https://hackage.haskell.org/package/hpath-io)
+

hpath-posix/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

hpath-posix/cbits/dirutils.c

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

hpath-posix/cbits/dirutils.h

@@ -7,7 +7,9 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 
+
 extern unsigned int
     __posixdir_d_type(struct dirent* d)
     ;
+
 #endif

hpath-posix/hpath-posix.cabal

@@ -0,0 +1,48 @@
+cabal-version:       >=1.10
+
+name:                hpath-posix
+version:             0.13.2
+synopsis:            Some low-level POSIX glue code, that is not in 'unix'
+homepage:            https://github.com/hasufell/hpath
+bug-reports:         https://github.com/hasufell/hpath/issues
+license:             BSD3
+license-file:        LICENSE
+author:              Julian Ospald <hasufell@posteo.de>
+maintainer:          Julian Ospald <hasufell@posteo.de>
+copyright:           Julian Ospald <hasufell@posteo.de> 2020
+category:            Filesystem
+build-type:          Simple
+extra-source-files:  CHANGELOG.md
+                     cbits/dirutils.h
+tested-with:         GHC==7.10.3
+                   , GHC==8.0.2
+                   , GHC==8.2.2
+                   , GHC==8.4.4
+                   , GHC==8.6.5
+                   , GHC==8.8.1
+
+library
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  exposed-modules:     System.Posix.RawFilePath.Directory.Traversals
+                       System.Posix.Foreign
+                       System.Posix.FD
+  -- other-modules:
+  -- other-extensions:
+  c-sources:           cbits/dirutils.c
+  build-depends:         base                >= 4.8  && <5
+                       , bytestring          >= 0.10
+                       , hpath-filepath      >= 0.10.3
+                       , unix                >= 2.5
+  if impl(ghc < 8.0)
+    build-depends:
+        fail >= 4.9
+
+  hs-source-dirs:      src
+  default-language:    Haskell2010
+  default-extensions: PackageImports
+
+source-repository head
+  type:     git
+  location: https://github.com/hasufell/hpath

hpath-posix/src/System/Posix/FD.hs

@@ -26,7 +26,7 @@ module System.Posix.FD (
 
 import Foreign.C.String
 import Foreign.C.Types
-import System.Posix.Directory.Foreign
+import System.Posix.Foreign
 import qualified System.Posix as Posix
 import System.Posix.ByteString.FilePath
 

hpath-posix/src/System/Posix/Foreign.hsc

@@ -1,4 +1,4 @@
-module System.Posix.Directory.Foreign where
+module System.Posix.Foreign where
 
 import Data.Bits
 import Data.List (foldl')

hpath-posix/src/System/Posix/RawFilePath/Directory/Traversals.hs

@@ -1,5 +1,5 @@
 -- |
--- Module      :  System.Posix.Directory.Traversals
+-- Module      :  System.Posix.RawFilePath.Directory.Traversals
 -- Copyright   :  © 2016 Julian Ospald
 -- License     :  BSD3
 --
@@ -10,16 +10,17 @@
 -- Traversal and read operations on directories.
 
 
+{-# LANGUAGE CApiFFI #-}
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE ForeignFunctionInterface #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PackageImports #-}
 {-# LANGUAGE TupleSections #-}
 {-# LANGUAGE ViewPatterns #-}
 
 {-# OPTIONS_GHC -Wall #-}
 
 
-module System.Posix.Directory.Traversals (
+module System.Posix.RawFilePath.Directory.Traversals (
 
   getDirectoryContents
 , getDirectoryContents'
@@ -37,10 +38,13 @@ module System.Posix.Directory.Traversals (
 , realpath
 ) where
 
-import Control.Applicative
+
+#if __GLASGOW_HASKELL__ < 710
+import Control.Applicative ((<$>))
+#endif
 import Control.Monad
 import System.Posix.FilePath ((</>))
-import System.Posix.Directory.Foreign
+import System.Posix.Foreign
 
 import qualified System.Posix as Posix
 import System.IO.Error
@@ -170,11 +174,15 @@ foreign import ccall unsafe "__hscore_d_name"
 foreign import ccall unsafe "__posixdir_d_type"
   c_type :: Ptr CDirent -> IO DirType
 
-foreign import ccall "realpath"
+foreign import capi "stdlib.h realpath"
   c_realpath :: CString -> CString -> IO CString
 
-foreign import ccall unsafe "fdopendir"
-  c_fdopendir :: Posix.Fd -> IO (Ptr ())
+-- Using normal 'ccall' here lead to memory bugs, crashes
+-- and corrupted d_name entries. It appears there are two fdopendirs:
+--   https://opensource.apple.com/source/Libc/Libc-1244.1.7/include/dirent.h.auto.html
+-- The capi call picks the correct one.
+foreign import capi unsafe "dirent.h fdopendir"
+  c_fdopendir :: Posix.Fd -> IO (Ptr CDir)
 
 ----------------------------------------------------------
 -- less dodgy but still lower-level
@@ -212,7 +220,7 @@ readDirEnt (unpackDirStream -> dirp) =
 getDirectoryContents :: RawFilePath -> IO [(DirType, RawFilePath)]
 getDirectoryContents path =
   modifyIOError ((`ioeSetFileName` (BS.unpack path)) .
-                 (`ioeSetLocation` "System.Posix.Directory.Traversals.getDirectoryContents")) $
+                 (`ioeSetLocation` "System.Posix.RawFilePath.Directory.Traversals.getDirectoryContents")) $
     bracket
       (PosixBS.openDirStream path)
       PosixBS.closeDirStream

hpath.cabal

@@ -1,108 +0,0 @@
-name:                hpath
-version:             0.7.3
-synopsis:            Support for well-typed paths
-description:         Support for well-typed paths, utilizing ByteString under the hood.
-license:             GPL-2
-license-file:        LICENSE
-author:              Julian Ospald <hasufell@posteo.de>
-maintainer:          Julian Ospald <hasufell@posteo.de>
-copyright:           Julian Ospald 2016
-category:            Filesystem
-build-type:          Simple
-cabal-version:       >=1.14
-extra-source-files:  README.md
-                     CHANGELOG
-                     cbits/dirutils.h
-                     doctests-hpath.hs
-                     doctests-posix.hs
-
-library
-  hs-source-dirs:    src/
-  default-language:  Haskell2010
-  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
-                   , exceptions
-                   , hspec
-                   , 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.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.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
-

hpath/CHANGELOG

@@ -1,3 +1,35 @@
+0.11.0
+	* Many API breaking changes
+	* Remove RelC and Fn, because they complicate API/break semantics (see #29)
+	* Redo 'parseAny'
+	* Unexpose HPath.Internal
+	* Don't preserve trailing path separators (if you need to pass something to a C function that way, do it manually)
+	* Added `rooPath`, `isRootPath`, `getAllComponents`, `getAllComponentsAfterRoot`
+0.10.2
+	* Add `parseAny` and the related QuasiQuoter
+0.10.1
+	* Add quasi quoters for hpath
+0.10.0
+	* split packages, this one now just contains the type-safe Path wrappers
+0.9.2
+	* fix build with ghc-7.6
+	* raise required bytestring version
+	* Tighten base bound to prevent building before GHC 7.6 (by George Wilson)
+0.9.1
+	* fix build with ghc-7.8 and 7.10
+0.9.0
+	* don't force "Path Abs" anymore in IO module, abstract more over Path types
+	* add 'toAbs'
+0.8.1
+	* add 'readFile', 'readFileEOF', 'writeFile' and 'appendFile'
+0.8.0
+	* 'copyDirRecursiveOverwrite', 'copyFileOverwrite', 'easyCopyOverwrite' and 'moveFileOverwrite' have been removed, instead use the versions without the *Overwrite suffix and pass in 'Strict' (for default behavior) or 'Overwrite' as the CopyMode argument
+	* introduced a new 'RecursiveErrorMode' type to allow controlling recursive behavior of 'copyDirRecursive' (use 'FailEarly' for default behavior)
+	* 'createRegularFile' and 'createDir' now take FileMode as a parameter (also see 'newFilePerms' and 'newDirPerms')
+	* various documentation fixes
+	* improved reliability of tests
+0.7.5:
+	* relicense to BSD3
 0.7.3:
 	* don't expose HPath.Internal
 0.7.2:

hpath/LICENSE

@@ -0,0 +1,30 @@
+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:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+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.
+
+3. Neither the name of the author nor the names of his contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

hpath/README.md

@@ -0,0 +1,40 @@
+# HPath
+
+[![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) [![Hackage-Deps](https://img.shields.io/hackage-deps/v/hpath.svg)](http://packdeps.haskellers.com/feed?needle=hpath)
+
+Support for well-typed paths in Haskell.
+
+This package is part of the HPath suite, also check out:
+
+* [hpath-directory](https://hackage.haskell.org/package/hpath-directory)
+* [hpath-filepath](https://hackage.haskell.org/package/hpath-filepath)
+* [hpath-io](https://hackage.haskell.org/package/hpath-io)
+
+## Motivation
+
+The motivation came during development of
+[hsfm](https://github.com/hasufell/hsfm)
+which has a pretty strict File type, but lacks a strict Path type, e.g.
+for user input.
+
+The library that came closest to my needs was
+[path](https://github.com/chrisdone/path),
+but the API turned out to be oddly complicated for my use case, so I
+decided to fork it.
+
+## Goals
+
+* well-typed paths
+* safe filepath manipulation, never using String as filepath, but ByteString
+
+Note: this library was written for __posix__ systems and it will probably not support other systems.
+
+## Differences to 'path'
+
+* 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...
+* 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
+* 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`

hpath/Setup.hs

@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain

hpath/hpath.cabal

@@ -0,0 +1,46 @@
+name:                hpath
+version:             0.11.0
+synopsis:            Support for well-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:           Julian Ospald 2016
+category:            Filesystem
+build-type:          Simple
+cabal-version:       1.14
+tested-with:         GHC==7.10.3
+                   , GHC==8.0.2
+                   , GHC==8.2.2
+                   , GHC==8.4.4
+                   , GHC==8.6.5
+                   , GHC==8.8.1
+extra-source-files:  README.md
+                     CHANGELOG
+
+library
+  if os(windows)
+    build-depends: unbuildable<0
+    buildable: False
+  hs-source-dirs:    src/
+  default-language:  Haskell2010
+  if impl(ghc >= 8.0)
+    ghc-options:       -Wall -Wno-redundant-constraints
+  else
+    ghc-options:       -Wall
+  exposed-modules:   HPath
+  other-modules:     HPath.Internal
+  build-depends:     base >= 4.8 && <5
+                   , bytestring >= 0.10.0.0
+                   , deepseq
+                   , exceptions
+                   , hpath-filepath >= 0.10 && < 0.11
+                   , template-haskell
+                   , utf8-string
+                   , word8
+
+source-repository head
+  type:     git
+  location: https://github.com/hasufell/hpath
+

hpath/run-doctests.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -e
+
+if [ -n "${SKIP_DOCTESTS}" ] ; then
+    echo "Skipping doctests"
+    exit 0
+fi
+
+if ! command -v doctest >/dev/null ; then
+    tempdir="$(mktemp -d)"
+    (
+     cd "${tempdir}"
+     cabal install --installdir="${tempdir}" doctest
+    )
+    export PATH="${tempdir}:$PATH"
+fi
+
+set -x
+
+cd "$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)"
+
+cabal exec doctest -- -isrc -XOverloadedStrings -XQuasiQuotes HPath

hpath/src/HPath.hs

@@ -13,7 +13,11 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE EmptyDataDecls #-}
+#if __GLASGOW_HASKELL__ >= 708
 {-# LANGUAGE PatternSynonyms #-}
+#endif
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TemplateHaskell #-}
 
 module HPath
   (
@@ -21,31 +25,39 @@ module HPath
    Abs
   ,Path
   ,Rel
-  ,Fn
   ,PathParseException
   ,PathException
-  ,RelC
+#if __GLASGOW_HASKELL__ >= 708
   -- * PatternSynonyms/ViewPatterns
   ,pattern Path
-   -- * Path Parsing
+#endif
+   -- * Path Construction
   ,parseAbs
-  ,parseFn
   ,parseRel
+  ,parseAny
+  ,rootPath
   -- * Path Conversion
   ,fromAbs
   ,fromRel
   ,toFilePath
+  ,fromAny
   -- * Path Operations
   ,(</>)
   ,basename
   ,dirname
-  ,isParentOf
   ,getAllParents
+  ,getAllComponents
+  ,getAllComponentsAfterRoot
   ,stripDir
+  -- * Path Examination
+  ,isParentOf
+  ,isRootPath
   -- * Path IO helpers
   ,withAbsPath
   ,withRelPath
-  ,withFnPath
+  -- * Quasiquoters
+  ,abs
+  ,rel
   )
   where
 
@@ -58,10 +70,15 @@ import           Data.ByteString(ByteString)
 import qualified Data.List as L
 #endif
 import qualified Data.ByteString as BS
+import           Data.ByteString.UTF8
 import           Data.Data
 import           Data.Maybe
 import           Data.Word8
 import           HPath.Internal
+import           Language.Haskell.TH
+import           Language.Haskell.TH.Syntax (Exp(..), Lift(..), lift)
+import           Language.Haskell.TH.Quote (QuasiQuoter(..))
+import           Prelude hiding (abs, any)
 import           System.Posix.FilePath hiding ((</>))
 
 
@@ -74,14 +91,10 @@ data Abs deriving (Typeable)
 -- | A relative path; one without a root.
 data Rel deriving (Typeable)
 
--- | A filename, without any '/'.
-data Fn deriving (Typeable)
-
 -- | Exception when parsing a location.
 data PathParseException
   = InvalidAbs ByteString
   | InvalidRel ByteString
-  | InvalidFn ByteString
   | Couldn'tStripPrefixTPS ByteString ByteString
   deriving (Show,Typeable)
 instance Exception PathParseException
@@ -90,10 +103,6 @@ data PathException = RootDirHasNoBasename
   deriving (Show,Typeable)
 instance Exception PathException
 
-class RelC m
-
-instance RelC Rel
-instance RelC Fn
 
 --------------------------------------------------------------------------------
 -- PatternSynonyms
@@ -101,7 +110,9 @@ instance RelC Fn
 #if __GLASGOW_HASKELL__ >= 710
 pattern Path :: ByteString -> Path a
 #endif
+#if __GLASGOW_HASKELL__ >= 708
 pattern Path x <- (MkPath x)
+#endif
 
 --------------------------------------------------------------------------------
 -- Path Parsers
@@ -119,7 +130,7 @@ pattern Path x <- (MkPath x)
 -- >>> parseAbs "/abc/def"      :: Maybe (Path Abs)
 -- Just "/abc/def"
 -- >>> parseAbs "/abc/def/.///" :: Maybe (Path Abs)
--- Just "/abc/def/"
+-- Just "/abc/def"
 -- >>> parseAbs "abc"           :: Maybe (Path Abs)
 -- Nothing
 -- >>> parseAbs ""              :: Maybe (Path Abs)
@@ -132,7 +143,7 @@ parseAbs filepath =
   if isAbsolute filepath &&
      isValid filepath &&
      not (hasParentDir filepath)
-     then return (MkPath $ normalise filepath)
+     then return (MkPath . dropTrailingPathSeparator . normalise $ filepath)
      else throwM (InvalidAbs filepath)
 
 
@@ -147,11 +158,11 @@ parseAbs filepath =
 -- >>> parseRel "abc"        :: Maybe (Path Rel)
 -- Just "abc"
 -- >>> parseRel "def/"       :: Maybe (Path Rel)
--- Just "def/"
+-- Just "def"
 -- >>> parseRel "abc/def"    :: Maybe (Path Rel)
 -- Just "abc/def"
 -- >>> parseRel "abc/def/."  :: Maybe (Path Rel)
--- Just "abc/def/"
+-- Just "abc/def"
 -- >>> parseRel "/abc"       :: Maybe (Path Rel)
 -- Nothing
 -- >>> parseRel ""           :: Maybe (Path Rel)
@@ -170,46 +181,46 @@ parseRel filepath =
      filepath /= BS.pack [_period, _period] &&
      not (hasParentDir filepath) &&
      isValid filepath
-     then return (MkPath $ normalise filepath)
+     then return (MkPath . dropTrailingPathSeparator . normalise $ filepath)
      else throwM (InvalidRel filepath)
 
 
--- | Parses a filename. Filenames must not contain slashes.
+
+-- | Parses a path, whether it's relative or absolute.
+--
 -- Excludes '.' and '..'.
 --
 -- Throws: 'PathParseException'
 --
--- >>> parseFn "abc"        :: Maybe (Path Fn)
--- Just "abc"
--- >>> parseFn "..."        :: Maybe (Path Fn)
--- Just "..."
--- >>> parseFn "def/"       :: Maybe (Path Fn)
+-- >>> parseAny "/abc"       :: Maybe (Either (Path Abs) (Path Rel))
+-- Just (Left "/abc")
+-- >>> parseAny "..."        :: Maybe (Either (Path Abs) (Path Rel))
+-- Just (Right "...")
+-- >>> parseAny "abc/def"    :: Maybe (Either (Path Abs) (Path Rel))
+-- Just (Right "abc/def")
+-- >>> parseAny "abc/def/."  :: Maybe (Either (Path Abs) (Path Rel))
+-- Just (Right "abc/def")
+-- >>> parseAny "/abc"       :: Maybe (Either (Path Abs) (Path Rel))
+-- Just (Left "/abc")
+-- >>> parseAny ""           :: Maybe (Either (Path Abs) (Path Rel))
 -- Nothing
--- >>> parseFn "abc/def"    :: Maybe (Path Fn)
+-- >>> parseAny "abc/../foo" :: Maybe (Either (Path Abs) (Path Rel))
 -- Nothing
--- >>> parseFn "abc/def/."  :: Maybe (Path Fn)
+-- >>> parseAny "."          :: Maybe (Either (Path Abs) (Path Rel))
 -- Nothing
--- >>> parseFn "/abc"       :: Maybe (Path Fn)
+-- >>> parseAny ".."         :: Maybe (Either (Path Abs) (Path Rel))
 -- 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)
+parseAny :: MonadThrow m => ByteString -> m (Either (Path Abs) (Path Rel))
+parseAny filepath = case parseAbs filepath of
+  Just p -> pure $ Left p
+  Nothing         -> case parseRel filepath of
+    Just p -> pure $ Right p
+    Nothing       -> throwM (InvalidRel filepath)
 
 
+rootPath :: Path Abs
+rootPath = (MkPath (BS.singleton _slash))
+
 
 --------------------------------------------------------------------------------
 -- Path Conversion
@@ -223,9 +234,11 @@ fromAbs :: Path Abs -> ByteString
 fromAbs = toFilePath
 
 -- | Convert a relative Path to a ByteString type.
-fromRel :: RelC r => Path r -> ByteString
+fromRel :: Path Rel -> ByteString
 fromRel = toFilePath
 
+fromAny :: Either (Path Abs) (Path Rel) -> ByteString
+fromAny = either toFilePath toFilePath
 
 
 --------------------------------------------------------------------------------
@@ -246,14 +259,15 @@ fromRel = toFilePath
 -- "/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 "/")        </> (MkPath "file"    :: Path Rel)
+-- "/file"
+(</>) :: Path b -> Path Rel -> Path b
 (</>) (MkPath a) (MkPath b) = MkPath (a' `BS.append` b)
   where
-    a' = if BS.last a == pathSeparator
-         then a
-         else addTrailingPathSeparator a
+    a' = if hasTrailingPathSeparator a
+            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.
@@ -281,6 +295,81 @@ stripDir (MkPath p) (MkPath l) =
   where
     p' = addTrailingPathSeparator p
 
+
+-- |Get all parents of a path.
+--
+-- >>> getAllParents (MkPath "/abs/def/dod")
+-- ["/abs/def","/abs","/"]
+-- >>> getAllParents (MkPath "/foo")
+-- ["/"]
+-- >>> getAllParents (MkPath "/")
+-- []
+getAllParents :: Path Abs -> [Path Abs]
+getAllParents (MkPath p)
+  | np == BS.singleton pathSeparator = []
+  | otherwise = dirname (MkPath np) : getAllParents (dirname $ MkPath np)
+  where
+    np = normalise p
+
+
+-- | Gets all path components.
+--
+-- >>> getAllComponents (MkPath "abs/def/dod")
+-- ["abs","def","dod"]
+-- >>> getAllComponents (MkPath "abs")
+-- ["abs"]
+getAllComponents :: Path Rel -> [Path Rel]
+getAllComponents (MkPath p) = fmap MkPath . splitDirectories $ p
+
+
+-- | Gets all path components after the "/" root directory.
+--
+-- >>> getAllComponentsAfterRoot (MkPath "/abs/def/dod")
+-- ["abs","def","dod"]
+-- >>> getAllComponentsAfterRoot (MkPath "/abs")
+-- ["abs"]
+getAllComponentsAfterRoot :: Path Abs -> [Path Rel]
+getAllComponentsAfterRoot p = getAllComponents (fromJust $ stripDir rootPath p)
+
+
+-- | Extract the directory name of a path.
+--
+-- >>> dirname (MkPath "/abc/def/dod")
+-- "/abc/def"
+-- >>> dirname (MkPath "/")
+-- "/"
+dirname :: Path Abs -> Path Abs
+dirname (MkPath fp) = MkPath (takeDirectory fp)
+
+-- | Extract the file part of a path.
+--
+--
+-- The following properties hold:
+--
+-- @basename (p \<\/> a) == basename a@
+--
+-- Throws: `PathException` if given the root path "/"
+--
+-- >>> basename (MkPath "/abc/def/dod") :: Maybe (Path Rel)
+-- Just "dod"
+-- >>> basename (MkPath "abc/def/dod")  :: Maybe (Path Rel)
+-- Just "dod"
+-- >>> basename (MkPath "dod")          :: Maybe (Path Rel)
+-- Just "dod"
+-- >>> basename (MkPath "/")            :: Maybe (Path Rel)
+-- Nothing
+basename :: MonadThrow m => Path b -> m (Path Rel)
+basename (MkPath l)
+  | not (isAbsolute rl) = return $ MkPath rl
+  | otherwise           = throwM RootDirHasNoBasename
+  where
+    rl = last . splitPath $ l
+
+
+
+--------------------------------------------------------------------------------
+-- Path Examination
+
 -- | Is p a parent of the given location? Implemented in terms of
 -- 'stripDir'. The bases must match.
 --
@@ -298,52 +387,14 @@ isParentOf :: Path b -> Path b -> Bool
 isParentOf p l = isJust (stripDir p l :: Maybe (Path Rel))
 
 
--- |Get all parents of a path.
+-- | Check whether the given Path is the root "/" 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.
---
--- The following properties hold:
---
--- @dirname (p \<\/> a) == dirname p@
---
--- >>> 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.
---
---
--- The following properties hold:
---
--- @basename (p \<\/> a) == basename a@
---
--- 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 (isAbsolute rl) = return $ MkPath rl
-  | otherwise           = throwM RootDirHasNoBasename
-  where
-    rl = last . splitPath . dropTrailingPathSeparator $ l
+-- >>> isRootPath (MkPath "/lal/lad")
+-- False
+-- >>> isRootPath (MkPath "/")
+-- True
+isRootPath :: Path Abs -> Bool
+isRootPath = (== rootPath)
 
 
 --------------------------------------------------------------------------------
@@ -358,9 +409,6 @@ 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
@@ -370,3 +418,52 @@ withFnPath (MkPath p) action = action p
 stripPrefix :: ByteString -> ByteString -> Maybe ByteString
 stripPrefix a b = BS.pack `fmap` L.stripPrefix (BS.unpack a) (BS.unpack b)
 #endif
+
+
+------------------------
+-- QuasiQuoters
+
+instance Lift (Path a) where
+  lift (MkPath bs) = AppE <$> [| MkPath . BS.pack |] <*> lift (BS.unpack bs)
+
+
+qq :: (ByteString -> Q Exp) -> QuasiQuoter
+qq quoteExp' =
+  QuasiQuoter
+  { quoteExp  = (\s -> quoteExp' . fromString $ s)
+  , quotePat  = \_ ->
+      fail "illegal QuasiQuote (allowed as expression only, used as a pattern)"
+  , quoteType = \_ ->
+      fail "illegal QuasiQuote (allowed as expression only, used as a type)"
+  , quoteDec  = \_ ->
+      fail "illegal QuasiQuote (allowed as expression only, used as a declaration)"
+  }
+
+mkAbs :: ByteString -> Q Exp
+mkAbs = either (error . show) lift . parseAbs
+
+mkRel :: ByteString -> Q Exp
+mkRel = either (error . show) lift . parseRel
+
+-- | Quasiquote an absolute Path. This accepts Unicode Chars and will encode as UTF-8.
+--
+-- >>> [abs|/etc/profile|] :: Path Abs
+-- "/etc/profile"
+-- >>> [abs|/|] :: Path Abs
+-- "/"
+-- >>> [abs|/|] :: Path Abs
+-- "/\239\131\144"
+abs :: QuasiQuoter
+abs = qq mkAbs
+
+-- | Quasiquote a relative Path. This accepts Unicode Chars and will encode as UTF-8.
+--
+-- >>> [rel|etc|] :: Path Rel
+-- "etc"
+-- >>> [rel|bar/baz|] :: Path Rel
+-- "bar/baz"
+-- >>> [rel||] :: Path Rel
+-- "\239\131\144"
+rel :: QuasiQuoter
+rel = qq mkRel
+

hpath/src/HPath/Internal.hs

@@ -10,15 +10,19 @@ import Control.DeepSeq (NFData (..))
 import Data.ByteString (ByteString)
 import Data.Data
 
--- | Path of some base and type.
+-- | The main Path type.
 --
--- Internally is a ByteString. The ByteString can be of two formats only:
+-- The type variable 'b' is either:
 --
--- 1. without trailing path separator: @file.txt@, @foo\/bar.txt@, @\/foo\/bar.txt@
--- 2. with trailing path separator: @foo\/@, @\/foo\/bar\/@
+--   * Abs -- absolute path
+--   * Rel -- relative path
 --
--- There are no duplicate
--- path separators @\/\/@, no @..@, no @.\/@, no @~\/@, etc.
+-- Internally is a ByteString. The path is guaranteed to
+-- be normalised and contain no trailing Path separators,
+-- except for the '/' root path.
+--
+-- There are no duplicate path separators
+-- @\/\/@, no @..@, no @.\/@, no @~\/@, etc.
 data Path b = MkPath ByteString
   deriving (Typeable)
 

src/HPath/IO.hs

@@ -1,898 +0,0 @@
--- |
--- Module      :  HPath.IO
--- Copyright   :  © 2016 Julian Ospald
--- License     :  GPL-2
---
--- 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(..)
-  -- * File copying
-  , copyDirRecursive
-  , copyDirRecursiveOverwrite
-  , recreateSymlink
-  , copyFile
-  , copyFileOverwrite
-  , easyCopy
-  , easyCopyOverwrite
-  -- * File deletion
-  , deleteFile
-  , deleteDir
-  , deleteDirRecursive
-  , easyDelete
-  -- * File opening
-  , openFile
-  , executeFile
-  -- * File creation
-  , createRegularFile
-  , createDir
-  , createSymlink
-  -- * File renaming/moving
-  , renameFile
-  , moveFile
-  , moveFileOverwrite
-  -- * File permissions
-  , newFilePerms
-  , newDirPerms
-  -- * Directory reading
-  , getDirsFiles
-  -- * Filetype operations
-  , getFileType
-  -- * Others
-  , canonicalizePath
-  )
-  where
-
-
-import Control.Applicative
-  (
-    (<$>)
-  )
-import Control.Exception
-  (
-    bracket
-  , throwIO
-  )
-import Control.Monad
-  (
-    void
-  , when
-  )
-import Data.ByteString
-  (
-    ByteString
-  )
-import Data.Foldable
-  (
-    for_
-  )
-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 HPath.IO.Utils
-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)
-
-
-
-
-
-    --------------------
-    --[ File Copying ]--
-    --------------------
-
-
-
--- |Copies a directory recursively to the given destination.
--- Does not follow symbolic links.
---
--- For directory contents, this has the same behavior as `easyCopy`
--- and thus will ignore any file type that is not `RegularFile`,
--- `SymbolicLink` or `Directory`.
---
--- 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 output directory is not writable
---    - `PermissionDenied` if source directory can't be opened
---    - `InvalidArgument` if source directory is wrong type (symlink)
---    - `InvalidArgument` if source directory is wrong type (regular file)
---    - `AlreadyExists` if destination already exists
---    - `SameFile` if source and destination are the same file (`HPathIOException`)
---    - `DestinationInSource` if destination is contained in source (`HPathIOException`)
-copyDirRecursive :: Path Abs  -- ^ source dir
-                 -> Path Abs  -- ^ full destination
-                 -> IO ()
-copyDirRecursive fromp destdirp
-  = do
-    -- for performance, sanity checks are only done for the top dir
-    throwSameFile fromp destdirp
-    throwDestinationInSource fromp destdirp
-    go fromp destdirp
-  where
-    go :: Path Abs -> Path Abs -> IO ()
-    go fromp' destdirp' = do
-      -- order is important here, so we don't get empty directories
-      -- on failure
-      contents <- getDirsFiles fromp'
-
-      fmode' <- PF.fileMode <$> PF.getSymbolicLinkStatus (fromAbs fromp')
-      createDirectory (fromAbs destdirp') fmode'
-
-      -- 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 -> recreateSymlink f newdest
-          Directory    -> go f newdest
-          RegularFile  -> copyFile f newdest
-          _            -> return ()
-
-
--- |Like `copyDirRecursive` except it overwrites contents of directories
--- if any.
---
--- For directory contents, this has the same behavior as `easyCopyOverwrite`
--- and thus will ignore any file type that is not `RegularFile`,
--- `SymbolicLink` or `Directory`.
---
--- Throws:
---
---    - `NoSuchThing` if source directory does not exist
---    - `PermissionDenied` if output directory is not writable
---    - `PermissionDenied` if source directory can't be opened
---    - `InvalidArgument` if source directory is wrong type (symlink)
---    - `InvalidArgument` if source directory is wrong type (regular file)
---    - `SameFile` if source and destination are the same file (`HPathIOException`)
---    - `DestinationInSource` if destination is contained in source (`HPathIOException`)
-copyDirRecursiveOverwrite :: Path Abs  -- ^ source dir
-                          -> Path Abs  -- ^ full destination
-                          -> IO ()
-copyDirRecursiveOverwrite fromp destdirp
-  = do
-    -- for performance, sanity checks are only done for the top dir
-    throwSameFile fromp destdirp
-    throwDestinationInSource fromp destdirp
-    go fromp destdirp
-  where
-    go :: Path Abs -> Path Abs -> IO ()
-    go fromp' destdirp' = do
-      -- order is important here, so we don't get empty directories
-      -- on failure
-      contents <- getDirsFiles fromp'
-
-      fmode' <- PF.fileMode <$> PF.getSymbolicLinkStatus (fromAbs fromp')
-      catchIOError (createDirectory (fromAbs destdirp') fmode') $ \e ->
-        case ioeGetErrorType e of
-          AlreadyExists -> setFileMode (fromAbs destdirp') fmode'
-          _             -> ioError e
-
-      -- we can't use `easyCopyOverwrite` here, because we want to call `go`
-      -- recursively to skip the top-level sanity checks
-      for_ contents $ \f -> do
-        ftype <- getFileType f
-        newdest <- (destdirp' </>) <$> basename f
-        case ftype of
-          SymbolicLink -> whenM (doesFileExist newdest) (deleteFile newdest)
-                          >> recreateSymlink f newdest
-          Directory    -> go f newdest
-          RegularFile  -> copyFileOverwrite f newdest
-          _            -> return ()
-
-
--- |Recreate a symlink.
---
--- Throws:
---
---    - `InvalidArgument` if source file is wrong type (not a symlink)
---    - `PermissionDenied` if output directory cannot be written to
---    - `PermissionDenied` if source directory cannot be opened
---    - `AlreadyExists` if destination file already exists
---    - `SameFile` if source and destination are the same file (`HPathIOException`)
---
--- Note: calls `symlink`
-recreateSymlink :: Path Abs  -- ^ the old symlink file
-                -> Path Abs  -- ^ destination file
-                -> IO ()
-recreateSymlink symsource newsym
-  = do
-    throwSameFile symsource newsym
-    sympoint <- readSymbolicLink (fromAbs symsource)
-    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.
---
--- Safety/reliability concerns:
---
---    * when used on `CharacterDevice`, reads the "contents" and copies
---      them to a regular file, which might take indefinitely
---    * when used on `BlockDevice`, may either read the "contents"
---      and copy them to a regular file (potentially hanging indefinitely)
---      or may create a regular empty destination file
---    * when used on `NamedPipe`, will hang indefinitely
---
--- 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)
---    - `AlreadyExists` if destination already exists
---    - `SameFile` if source and destination are the same file (`HPathIOException`)
---
--- Note: calls `sendfile` and possibly `read`/`write` as fallback
-copyFile :: Path Abs  -- ^ source file
-         -> Path Abs  -- ^ destination file
-         -> IO ()
-copyFile from to = do
-  throwSameFile from to
-  _copyFile [SPDF.oNofollow]
-            [SPDF.oNofollow, SPDF.oExcl]
-            from to
-
-
--- |Like `copyFile` except it overwrites the destination if it already
--- exists.
---
--- Safety/reliability concerns:
---
---    * when used on `CharacterDevice`, reads the "contents" and copies
---      them to a regular file, which might take indefinitely
---    * when used on `BlockDevice`, may either read the "contents"
---      and copy them to a regular file (potentially hanging indefinitely)
---      or may create a regular empty destination file
---    * when used on `NamedPipe`, will hang indefinitely
---    * not atomic, since it uses read/write
---
--- Throws:
---
---    - `NoSuchThing` if source file does not exist
---    - `NoSuchThing` if source file is a `Socket`
---    - `PermissionDenied` if output directory is not writable
---    - `PermissionDenied` if source directory can't be opened
---    - `InvalidArgument` if source file is wrong type (symlink or directory)
---    - `SameFile` if source and destination are the same file (`HPathIOException`)
---
--- Note: calls `sendfile` and possibly `read`/`write` as fallback
-copyFileOverwrite :: Path Abs  -- ^ source file
-                  -> Path Abs  -- ^ destination file
-                  -> IO ()
-copyFileOverwrite from to = do
-  throwSameFile from to
-  catchIOError (_copyFile [SPDF.oNofollow]
-                          [SPDF.oNofollow, SPDF.oTrunc]
-                          from to) $ \e ->
-    case ioeGetErrorType e of
-      -- if the destination file is not writable, we need to
-      -- figure out if we can still copy by deleting it first
-      PermissionDenied -> do
-        exists   <- doesFileExist to
-        writable <- isWritable (dirname to)
-        if exists && writable
-          then deleteFile to >> copyFile from to
-          else ioError e
-      _ -> ioError e
-
-
-_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
-         -> IO ()
-easyCopy from to = do
-  ftype <- getFileType from
-  case ftype of
-       SymbolicLink -> recreateSymlink from to
-       RegularFile  -> copyFile from to
-       Directory    -> copyDirRecursive from to
-       _            -> return ()
-
-
--- |Like `easyCopy` except it overwrites the destination if it already exists.
--- For directories, this overwrites contents without pruning them, so the resulting
--- directory may have more files than have been copied.
---
--- Safety/reliability concerns:
---
---    * examines filetypes explicitly
---    * calls `copyDirRecursive` for directories
-easyCopyOverwrite :: Path Abs
-                  -> Path Abs
-                  -> IO ()
-easyCopyOverwrite from to = do
-  ftype <- getFileType from
-  case ftype of
-       SymbolicLink -> whenM (doesFileExist to) (deleteFile to)
-                       >> recreateSymlink from to
-       RegularFile  -> copyFileOverwrite from to
-       Directory    -> copyDirRecursiveOverwrite from to
-       _            -> return ()
-
-
-
-
-
-
-    ---------------------
-    --[ 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 :: Path Abs -> IO ()
-createRegularFile dest =
-  bracket (SPI.openFd (fromAbs dest) SPI.WriteOnly (Just newFilePerms)
-                      (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 :: Path Abs -> IO ()
-createDir dest = createDirectory (fromAbs dest) newDirPerms
-
-
--- |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:
---
---    * 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
---
--- Throws:
---
---     - `NoSuchThing` if source file does not exist
---     - `PermissionDenied` if output directory cannot be written to
---     - `PermissionDenied` if source directory cannot be opened
---     - `FileDoesExist` if destination file already exists (`HPathIOException`)
---     - `DirDoesExist` if destination directory already exists (`HPathIOException`)
---     - `SameFile` if destination and source are the same file (`HPathIOException`)
---
--- Note: calls `rename` (but does not allow to rename over existing files)
-moveFile :: Path Abs  -- ^ file to move
-         -> Path Abs  -- ^ destination
-         -> IO ()
-moveFile from to = do
-  throwSameFile from to
-  catchErrno [eXDEV] (renameFile from to) $ do
-    easyCopy from to
-    easyDelete from
-
-
--- |Like `moveFile`, but overwrites the destination if it exists.
---
--- Does not follow symbolic links, but renames the symbolic link file.
---
--- Ignores any file type that is not `RegularFile`, `SymbolicLink` or
--- `Directory`.
---
--- Safety/reliability concerns:
---
---    * copy-delete fallback is inherently non-atomic
---    * checks for file types and destination file existence explicitly
---
--- 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`)
---
--- Note: calls `rename` (but does not allow to rename over existing files)
-moveFileOverwrite :: Path Abs  -- ^ file to move
-                  -> Path Abs  -- ^ destination
-                  -> IO ()
-moveFileOverwrite from to = do
-  throwSameFile from to
-  ft <- getFileType from
-  writable <- isWritable $ dirname to
-  case ft of
-    RegularFile -> do
-      exists <- doesFileExist to
-      when (exists && writable) (deleteFile to)
-    SymbolicLink -> do
-      exists <- doesFileExist to
-      when (exists && writable) (deleteFile to)
-    Directory -> do
-      exists <- doesDirectoryExist to
-      when (exists && writable) (deleteDir to)
-    _ -> return ()
-  moveFile from to
-
-
-
-
-    -----------------------
-    --[ 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.
---
--- 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

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

src/HPath/IO/Errors.hs

@@ -1,359 +0,0 @@
--- |
--- Module      :  HPath.IO.Errors
--- Copyright   :  © 2016 Julian Ospald
--- License     :  GPL-2
---
--- 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
-
-  -- * 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.Data
-  (
-    Data(..)
-  )
-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
-  deriving (Typeable, Eq, Data)
-
-
-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
-
-
-
-instance Exception HPathIOException
-
-
-
-
-
-    -----------------------------
-    --[ Exception identifiers ]--
-    -----------------------------
-
-isFileDoesNotExist, isDirDoesNotExist, isSameFile, isDestinationInSource, isFileDoesExist, isDirDoesExist, isInvalidOperation, isCan'tOpenDirectory, isCopyFailed :: HPathIOException -> Bool
-isFileDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr FileDoesNotExist{}
-isDirDoesNotExist ex = toConstr (ex :: HPathIOException) == toConstr DirDoesNotExist{}
-isSameFile 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{}
-
-
-
-
-    ----------------------------
-    --[ 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

@@ -1,32 +0,0 @@
--- |
--- Module      :  HPath.IO.Utils
--- Copyright   :  © 2016 Julian Ospald
--- License     :  GPL-2
---
--- Maintainer  :  Julian Ospald <hasufell@posteo.de>
--- Stability   :  experimental
--- Portability :  portable
---
--- Random and general IO/monad utilities.
-
-
-module HPath.IO.Utils where
-
-
-import Control.Monad
-  (
-    when
-  , unless
-  )
-
-
--- |If the value of the first argument is True, then execute the action
--- provided in the second argument, otherwise do nothing.
-whenM :: Monad m => m Bool -> m () -> m ()
-whenM mb a = mb >>= (`when` a)
-
-
--- |If the value of the first argument is False, then execute the action
--- provided in the second argument, otherwise do nothing.
-unlessM :: Monad m => m Bool -> m () -> m ()
-unlessM mb a = mb >>= (`unless` a)

test/HPath/IO/CopyDirRecursiveOverwriteSpec.hs

@@ -1,169 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
-
-module HPath.IO.CopyDirRecursiveOverwriteSpec where
-
-
-import Test.Hspec
-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)
-
-
-
-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 = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.copyDirRecursiveOverwrite" $ do
-
-    -- successes --
-    it "copyDirRecursiveOverwrite, all fine" $ do
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "outputDir"
-      removeDirIfExists "outputDir"
-
-    it "copyDirRecursiveOverwrite, all fine and compare" $ do
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "outputDir"
-      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "outputDir")
-        `shouldReturn` ExitSuccess
-      removeDirIfExists "outputDir"
-
-    it "copyDirRecursiveOverwrite, destination dir already exists" $ do
-      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "alreadyExistsD")
-        `shouldReturn` (ExitFailure 1)
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "alreadyExistsD"
-      (system $ "diff -r --no-dereference "
-                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ toString tmpDir ++ "alreadyExistsD")
-        `shouldReturn` ExitSuccess
-      removeDirIfExists "outputDir"
-
-    -- posix failures --
-    it "copyDirRecursiveOverwrite, source directory does not exist" $
-      copyDirRecursiveOverwrite' "doesNotExist"
-                                 "outputDir"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == NoSuchThing)
-
-    it "copyDirRecursiveOverwrite, no write permission on output dir" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "noWritePerm/foo"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    it "copyDirRecursiveOverwrite, cannot open output dir" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "noPerms/foo"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    it "copyDirRecursiveOverwrite, cannot open source dir" $
-      copyDirRecursiveOverwrite' "noPerms/inputDir"
-                                 "foo"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    it "copyDirRecursiveOverwrite, destination already exists and is a file" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "alreadyExists"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == InappropriateType)
-
-    it "copyDirRecursiveOverwrite, wrong input (regular file)" $
-      copyDirRecursiveOverwrite' "wrongInput"
-                                 "outputDir"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == InappropriateType)
-
-    it "copyDirRecursiveOverwrite, wrong input (symlink to directory)" $
-      copyDirRecursiveOverwrite' "wrongInputSymL"
-                                 "outputDir"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == InvalidArgument)
-
-    -- custom failures
-    it "copyDirRecursiveOverwrite, destination in source" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "inputDir/foo"
-        `shouldThrow`
-        isDestinationInSource
-
-    it "copyDirRecursiveOverwrite, destination and source same directory" $
-      copyDirRecursiveOverwrite' "inputDir"
-                                 "inputDir"
-        `shouldThrow`
-        isSameFile

test/HPath/IO/MoveFileOverwriteSpec.hs

@@ -1,109 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
-module HPath.IO.MoveFileOverwriteSpec where
-
-
-import Test.Hspec
-import HPath.IO.Errors
-import System.IO.Error
-  (
-    ioeGetErrorType
-  )
-import GHC.IO.Exception
-  (
-    IOErrorType(..)
-  )
-import Utils
-import qualified Data.ByteString as BS
-import           Data.ByteString.UTF8 (toString)
-
-
-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 = before_ setupFiles $ after_ cleanupFiles $
-  describe "HPath.IO.moveFileOverwrite" $ do
-
-    -- successes --
-    it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' "myFile"
-                         "movedFile"
-
-    it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' "myFile"
-                         "dir/movedFile"
-
-    it "moveFileOverwrite, all fine on symlink" $
-      moveFileOverwrite' "myFileL"
-                         "movedFile"
-
-    it "moveFileOverwrite, all fine on directory" $
-      moveFileOverwrite' "dir"
-                         "movedFile"
-
-    it "moveFileOverwrite, destination file already exists" $
-      moveFileOverwrite' "myFile"
-                         "alreadyExists"
-
-    -- posix failures --
-    it "moveFileOverwrite, source file does not exist" $
-      moveFileOverwrite' "fileDoesNotExist"
-                         "movedFile"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == NoSuchThing)
-
-    it "moveFileOverwrite, can't write to destination directory" $
-      moveFileOverwrite' "myFile"
-                         "noWritePerm/movedFile"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    it "moveFileOverwrite, can't open destination directory" $
-      moveFileOverwrite' "myFile"
-                         "noPerms/movedFile"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    it "moveFileOverwrite, can't open source directory" $
-      moveFileOverwrite' "noPerms/myFile"
-                         "movedFile"
-        `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied)
-
-    -- custom failures --
-    it "moveFileOverwrite, move from file to dir" $
-      moveFileOverwrite' "myFile"
-                         "alreadyExistsD"
-        `shouldThrow`
-        isDirDoesExist
-
-    it "moveFileOverwrite, source and dest are same file" $
-      moveFileOverwrite' "myFile"
-                         "myFile"
-        `shouldThrow`
-        isSameFile
-

test/Main.hs

@@ -1,23 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
-import Test.Hspec
-import Test.Hspec.Runner
-import Test.Hspec.Formatters
-import qualified Spec
-import Utils
-
-
--- TODO: chardev, blockdev, namedpipe, socket
-
-
-main :: IO ()
-main =
-  hspecWith
-    defaultConfig { configFormatter = Just progress }
-    $ before_ up
-    $ after_ down
-    $ Spec.spec
-  where
-    up = createTmpDir
-    down = deleteTmpDir
-

test/Utils.hs

@@ -1,221 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PackageImports #-}
-
-
-module Utils where
-
-
-import Control.Applicative
-  (
-    (<$>)
-  )
-import Control.Monad
-  (
-    void
-  )
-import HPath.IO
-import HPath.IO.Errors
-import HPath.IO.Utils
-import Data.Maybe
-  (
-    fromJust
-  )
-import qualified HPath as P
-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
-
-
-
-tmpDir :: ByteString
-tmpDir = "test/HPath/IO/tmp/"
-
-
-
-    -----------------
-    --[ Utilities ]--
-    -----------------
-
-
-createTmpDir :: IO ()
-createTmpDir = do
-  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
-  void $ createDir (pwd P.</> tmp)
-
-
-deleteTmpDir :: IO ()
-deleteTmpDir = do
-  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
-  void $ deleteDir (pwd P.</> tmp)
-
-
-withRawTmpDir :: (P.Path P.Abs -> IO a) -> IO a
-withRawTmpDir f = do
-  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
-  f (pwd P.</> tmp)
-
-
-withTmpDir :: ByteString -> (P.Path P.Abs -> IO a) -> IO a
-withTmpDir ip f = do
-  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel 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
-withTmpDir' ip1 ip2 f = do
-  pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
-  tmp <- P.parseRel tmpDir
-  p1 <- (pwd P.</> tmp P.</>) <$> P.parseRel ip1
-  p2 <- (pwd P.</> tmp P.</>) <$> P.parseRel ip2
-  f p1 p2
-
-
-removeFileIfExists :: ByteString -> IO ()
-removeFileIfExists bs =
-  withTmpDir bs $ \p -> whenM (doesFileExist p) (deleteFile p)
-
-
-removeDirIfExists :: ByteString -> IO ()
-removeDirIfExists bs =
-  withTmpDir bs $ \p -> whenM (doesDirectoryExist p) (deleteDirRecursive p)
-
-
-copyFile' :: ByteString -> ByteString -> IO ()
-copyFile' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP copyFile
-
-
-copyFileOverwrite' :: ByteString -> ByteString -> IO ()
-copyFileOverwrite' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP copyFileOverwrite
-
-
-copyDirRecursive' :: ByteString -> ByteString -> IO ()
-copyDirRecursive' inputDirP outputDirP =
-  withTmpDir' inputDirP outputDirP copyDirRecursive
-
-
-copyDirRecursiveOverwrite' :: ByteString -> ByteString -> IO ()
-copyDirRecursiveOverwrite' inputDirP outputDirP =
-  withTmpDir' inputDirP outputDirP copyDirRecursiveOverwrite
-
-
-createDir' :: ByteString -> IO ()
-createDir' dest = withTmpDir dest createDir
-
-
-createRegularFile' :: ByteString -> IO ()
-createRegularFile' dest = withTmpDir dest createRegularFile
-
-
-createSymlink' :: ByteString -> ByteString -> IO ()
-createSymlink' dest sympoint = withTmpDir dest
-  (\x -> createSymlink x sympoint)
-
-
-renameFile' :: ByteString -> ByteString -> IO ()
-renameFile' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP $ \i o -> do
-    renameFile i o
-    renameFile o i
-
-
-moveFile' :: ByteString -> ByteString -> IO ()
-moveFile' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP $ \i o -> do
-    moveFile i o
-    moveFile o i
-
-
-moveFileOverwrite' :: ByteString -> ByteString -> IO ()
-moveFileOverwrite' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP $ \i o -> do
-    moveFileOverwrite i o
-    moveFile o i
-
-
-recreateSymlink' :: ByteString -> ByteString -> IO ()
-recreateSymlink' inputFileP outputFileP =
-  withTmpDir' inputFileP outputFileP recreateSymlink
-
-
-noWritableDirPerms :: ByteString -> IO ()
-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 ()
-noPerms path = withTmpDir path $ \p -> setFileMode (P.fromAbs p) nullFileMode
-
-
-normalDirPerms :: ByteString -> IO ()
-normalDirPerms path =
-  withTmpDir path $ \p -> setFileMode (P.fromAbs p) newDirPerms
-
-
-getFileType' :: ByteString -> IO FileType
-getFileType' path = withTmpDir path getFileType
-
-
-getDirsFiles' :: ByteString -> IO [P.Path P.Abs]
-getDirsFiles' path = withTmpDir path getDirsFiles
-
-
-deleteFile' :: ByteString -> IO ()
-deleteFile' p = withTmpDir p deleteFile
-
-
-deleteDir' :: ByteString -> IO ()
-deleteDir' p = withTmpDir p deleteDir
-
-
-deleteDirRecursive' :: ByteString -> IO ()
-deleteDirRecursive' p = withTmpDir p deleteDirRecursive
-
-
-canonicalizePath' :: ByteString -> IO (P.Path P.Abs)
-canonicalizePath' p = withTmpDir p canonicalizePath
-
-
-writeFile' :: ByteString -> ByteString -> IO ()
-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

update-gh-pages.sh

@@ -1,52 +0,0 @@
-#!/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
-