Compare commits
174 Commits
Author | SHA1 | Date |
---|---|---|
Julian Ospald | d2f89df9b1 | |
Julian Ospald | 5c1d8ed455 | |
Julian Ospald | 270d007e40 | |
Julian Ospald | ae21dbc7fa | |
Julian Ospald | 014d78e055 | |
Julian Ospald | 3cb17dd253 | |
Julian Ospald | 54bea3b9c2 | |
Julian Ospald | 572fbfa59a | |
Julian Ospald | 92cc84377d | |
Julian Ospald | 74d686547e | |
Julian Ospald | 06b5a46cf8 | |
Julian Ospald | 13674f39b3 | |
Julian Ospald | bb86e3ba24 | |
Julian Ospald | ec9884276c | |
Julian Ospald | 23f4221fe1 | |
Julian Ospald | d21b7bed3b | |
Julian Ospald | 25083b293d | |
Julian Ospald | 09f25deecc | |
Julian Ospald | 1d7ffca4ac | |
Julian Ospald | 33e68590b2 | |
Julian Ospald | e1f302b4a6 | |
Julian Ospald | 4df7e02e27 | |
Julian Ospald | ecb52f5217 | |
Julian Ospald | 768443df27 | |
Julian Ospald | f7e2131192 | |
Julian Ospald | 87e452c49f | |
Julian Ospald | 1d00ae469d | |
Julian Ospald | d4402a25bb | |
Julian Ospald | 0c770be3a5 | |
Julian Ospald | f3f232e4c9 | |
Julian Ospald | b7cd5ba857 | |
Julian Ospald | 7d0ca1c230 | |
Julian Ospald | a6036a7aea | |
Julian Ospald | 0ff3808544 | |
Julian Ospald | 9d8b7d5bfc | |
Julian Ospald | d0beba227a | |
Julian Ospald | 607e67378c | |
Julian Ospald | 7b66379d49 | |
Julian Ospald | db23ad6b38 | |
Julian Ospald | f2986e60db | |
Julian Ospald | 1eeef0806d | |
Julian Ospald | 375d8ae0a3 | |
Julian Ospald | 3abc68cdd6 | |
Julian Ospald | 117641c419 | |
Julian Ospald | 824aff1751 | |
Julian Ospald | 94077aa6a6 | |
Julian Ospald | 22ddeeadcc | |
Julian Ospald | 1f4e289903 | |
Julian Ospald | bb24a57e36 | |
Julian Ospald | 9e831749c0 | |
Julian Ospald | dc2493427c | |
Julian Ospald | d898af171d | |
Julian Ospald | 80d60845dc | |
Julian Ospald | 5b9958ba23 | |
Julian Ospald | 9b20ce2e72 | |
Julian Ospald | 6a1f80bc17 | |
Julian Ospald | 931851c8c1 | |
Julian Ospald | 3b6eb46dc9 | |
Julian Ospald | 0ae398df39 | |
Julian Ospald | fe92de9abd | |
Julian Ospald | c49d36d1c3 | |
Julian Ospald | a6f902a9df | |
Julian Ospald | d0c3a2c9a7 | |
Julian Ospald | c3d2c0433e | |
Julian Ospald | dc131c3e6b | |
Julian Ospald | ca59169f02 | |
Julian Ospald | 09eea518b8 | |
Julian Ospald | 4e07fcf5b2 | |
Julian Ospald | a343d43b5c | |
Julian Ospald | fda03eb27a | |
Julian Ospald | a487f02894 | |
Julian Ospald | 8412ea96fb | |
Julian Ospald | 28e0d1d635 | |
Julian Ospald | c9013e5a2a | |
Julian Ospald | 1d03ec78b3 | |
Julian Ospald | f5c541b9cc | |
Julian Ospald | 3529ec2a15 | |
Julian Ospald | 7db7a9402f | |
Julian Ospald | 21dd1718c0 | |
Julian Ospald | 2e0fe6b698 | |
Julian Ospald | 200fc9b581 | |
Julian Ospald | 4ac3ee3e42 | |
Julian Ospald | 035c364b35 | |
Julian Ospald | 6bc5381108 | |
Julian Ospald | ef51863180 | |
Julian Ospald | 09062351f5 | |
Julian Ospald | ab4137572e | |
Julian Ospald | c03a7ec18f | |
George Wilson | df298f187e | |
Julian Ospald | 466c72924a | |
Julian Ospald | 9dfb803ba8 | |
Julian Ospald | de46a0c568 | |
Julian Ospald | d9ba67b6f0 | |
Julian Ospald | 9342abeb7a | |
Julian Ospald | e8cbc632c9 | |
Julian Ospald | c556a3d3e4 | |
Julian Ospald | 3aee719130 | |
Julian Ospald | 10662ee803 | |
Julian Ospald | 672875f48f | |
Julian Ospald | 3e6d93182a | |
Julian Ospald | 1c95c9f8f9 | |
Julian Ospald | 0ec2cf8ca5 | |
Julian Ospald | 9ac10a6a7d | |
Julian Ospald | 1a2c77c6a6 | |
Julian Ospald | 3baecb7b51 | |
Julian Ospald | 5d5b0ae3c1 | |
Julian Ospald | f47c8edb42 | |
Julian Ospald | ef66a24f87 | |
Julian Ospald | f6a5cb8668 | |
Julian Ospald | 4dec385332 | |
Julian Ospald | 5b08e14b55 | |
Julian Ospald | ac381cbf60 | |
Julian Ospald | ce7fdcdcd6 | |
Julian Ospald | a31c9d1e88 | |
Julian Ospald | a5942ff026 | |
Julian Ospald | 4d71ad08ce | |
Julian Ospald | 92017ab630 | |
Julian Ospald | 16af98b32d | |
Julian Ospald | 6da01e382f | |
Julian Ospald | ed06543981 | |
Julian Ospald | d3eb2fc254 | |
Julian Ospald | a1eb06324f | |
Julian Ospald | d12ce30f57 | |
Julian Ospald | 7a6f0e8728 | |
Julian Ospald | 7ed5829d47 | |
Julian Ospald | d708f80a1f | |
Julian Ospald | f07619b7c6 | |
Julian Ospald | c5bcb90b65 | |
Julian Ospald | 4f047dbc77 | |
Julian Ospald | bc348c7dd5 | |
Julian Ospald | 5d1c5cc2ce | |
Julian Ospald | 8f6ca81d22 | |
Julian Ospald | a27d4ed55d | |
Julian Ospald | 64ae6db83a | |
Julian Ospald | 2a0a88a96d | |
Julian Ospald | 69dbf6714d | |
Julian Ospald | 2d96311b33 | |
Julian Ospald | 21668f12fe | |
Julian Ospald | 6e37e18bc8 | |
Julian Ospald | ae24f87c74 | |
Julian Ospald | 9f6734e700 | |
Julian Ospald | 741c510b91 | |
Julian Ospald | bb590a7692 | |
Julian Ospald | 641e23c3ef | |
Julian Ospald | 82ea75cc88 | |
Julian Ospald | abf043be14 | |
Julian Ospald | 10adc4be27 | |
Julian Ospald | a176e4970b | |
Julian Ospald | 08de2ebefb | |
Julian Ospald | d15d7761c1 | |
Julian Ospald | 7e924d3386 | |
Julian Ospald | 21fccc9ca9 | |
Julian Ospald | 79dbcd8b55 | |
Julian Ospald | b603f72407 | |
Julian Ospald | 98ca6c5d86 | |
Julian Ospald | 8d948366f9 | |
Julian Ospald | 86e7496917 | |
Julian Ospald | 1b9b8cc886 | |
Julian Ospald | 395621b27a | |
Julian Ospald | 51da8bf5c2 | |
Julian Ospald | bebc96fa6d | |
Julian Ospald | 08fa277b31 | |
Julian Ospald | 51609781b2 | |
Julian Ospald | 3cb3a822d7 | |
Julian Ospald | 7fa4c041a9 | |
Julian Ospald | e66074af1c | |
Julian Ospald | 4032629407 | |
Julian Ospald | f2fe5a3419 | |
Julian Ospald | 5ac7450495 | |
Julian Ospald | b55cf6d9f3 | |
Julian Ospald | ae9a806c2e | |
Julian Ospald | 9c199c6da2 | |
Julian Ospald | eb72fce33f | |
Julian Ospald | 65bb09d133 |
|
@ -8,5 +8,7 @@ TAGS
|
|||
tags
|
||||
*.tag
|
||||
.stack-work/
|
||||
dist/
|
||||
dist-newstyle/
|
||||
.cabal-sandbox/
|
||||
cabal.sandbox.config
|
||||
|
|
81
.travis.yml
81
.travis.yml
|
@ -7,41 +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.22 GHCVER=7.10.2
|
||||
addons: {apt: {packages: [cabal-install-1.22,ghc-7.10.2], 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
|
||||
|
||||
before_install:
|
||||
- export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
|
||||
env:
|
||||
global:
|
||||
- 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
|
||||
# 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
|
||||
- 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:
|
||||
|
|
49
CHANGELOG
49
CHANGELOG
|
@ -1,49 +0,0 @@
|
|||
0.7.0:
|
||||
* use 'sendfile' from 'simple-sendfile' in _copyFile and do read/write as a fallback only
|
||||
* add isFileName, hasParentDir, hiddenFile to System.Posix.FilePath
|
||||
* add our own openFd version for more control
|
||||
* small documentation improvements
|
||||
* add a getDirectoryContents' version that works on Fd
|
||||
* lift version constraints in benchmark
|
||||
* remove fpToString and userStringToFP, use Data.ByteString.UTF8 directly instead
|
||||
0.6.0:
|
||||
* fixes 'throwDestinationInSource' to be more reliable.
|
||||
* removes some unused HPathIOException constructors
|
||||
* consistently provide exception constructor identifiers
|
||||
* be less harsh when non-supported file types get passed to our functions, possibly ignoring them
|
||||
* minor cleanups
|
||||
0.5.9:
|
||||
* Adds our posix-paths fork and a lot of IO operations.
|
||||
0.5.8:
|
||||
* First version of the fork.
|
||||
0.5.7:
|
||||
* Fix haddock problem.
|
||||
0.5.6:
|
||||
* Reject only .. and .
|
||||
0.5.5:
|
||||
* Use filepath's isValid function for additional sanity checks
|
||||
0.5.4:
|
||||
* Disable parsing of path consisting only of "."
|
||||
* Add NFData instance for Path
|
||||
* Some typo/docs improvements
|
||||
* Add standard headers to modules
|
||||
0.5.3:
|
||||
* Added conversion functions.
|
||||
|
||||
0.2.0:
|
||||
|
||||
* Rename parentAbs to simply parent.
|
||||
* Add dirname.
|
||||
|
||||
0.3.0:
|
||||
* Removed Generic instance.
|
||||
|
||||
0.4.0:
|
||||
* Implemented stricter parsing, disabling use of "..".
|
||||
* Made stripDir generic over MonadThrow
|
||||
|
||||
0.5.0:
|
||||
* Fix stripDir p p /= Nothing bug.
|
||||
|
||||
0.5.2:
|
||||
* Removed unused DeriveGeneric.
|
340
LICENSE
340
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.
|
||||
|
56
README.md
56
README.md
|
@ -1,51 +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
|
||||
|
||||
## 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'
|
||||
|
||||
* `hasTrailingPathSeparator` behaves in the same way as `System.FilePath`
|
||||
* `dropTrailingPathSeparator` behaves in the same way as `System.FilePath`
|
||||
* added various functions like `isValid`, `normalise` and `equalFilePath`
|
||||
* uses the `word8` package for save word8 literals instead of `OverloadedStrings`
|
||||
* has custom versions of `openFd` and `getDirectoryContents`
|
||||
## 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'
|
||||
|
|
|
@ -1,90 +0,0 @@
|
|||
{-# LANGUAGE ForeignFunctionInterface #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE TupleSections #-}
|
||||
{-# LANGUAGE ViewPatterns #-}
|
||||
|
||||
{-# OPTIONS_GHC -Wall #-}
|
||||
import Control.Applicative
|
||||
import Control.Monad
|
||||
import System.Directory
|
||||
import System.FilePath ((</>))
|
||||
import System.Posix.ByteString.FilePath
|
||||
import System.Posix.Directory.ByteString as PosixBS
|
||||
import System.Posix.Directory.Traversals
|
||||
import qualified System.Posix.FilePath as PosixBS
|
||||
import System.Posix.Files.ByteString
|
||||
|
||||
import Control.Exception
|
||||
import qualified Data.ByteString.Char8 as BS
|
||||
|
||||
import System.Environment (getArgs, withArgs)
|
||||
import System.IO.Error
|
||||
import System.IO.Unsafe
|
||||
import System.Process (system)
|
||||
import Criterion.Main
|
||||
|
||||
|
||||
-- | Based on code from 'Real World Haskell', at
|
||||
-- http://book.realworldhaskell.org/read/io-case-study-a-library-for-searching-the-filesystem.html#id620419
|
||||
listFilesRecursive :: FilePath -> IO [FilePath]
|
||||
listFilesRecursive topdir = do
|
||||
names <- System.Directory.getDirectoryContents topdir
|
||||
let properNames = filter (`notElem` [".", ".."]) names
|
||||
paths <- forM properNames $ \name -> do
|
||||
let path = topdir </> name
|
||||
isDir <- doesDirectoryExist path
|
||||
if isDir
|
||||
then listFilesRecursive path
|
||||
else return [path]
|
||||
return (topdir : concat paths)
|
||||
|
||||
----------------------------------------------------------
|
||||
|
||||
getDirectoryContentsBS :: RawFilePath -> IO [RawFilePath]
|
||||
getDirectoryContentsBS path =
|
||||
modifyIOError ((`ioeSetFileName` (BS.unpack path)) .
|
||||
(`ioeSetLocation` "getDirectoryContentsBS")) $ do
|
||||
bracket
|
||||
(PosixBS.openDirStream path)
|
||||
PosixBS.closeDirStream
|
||||
loop
|
||||
where
|
||||
loop dirp = do
|
||||
e <- PosixBS.readDirStream dirp
|
||||
if BS.null e then return [] else do
|
||||
es <- loop dirp
|
||||
return (e:es)
|
||||
|
||||
|
||||
-- | similar to 'listFilesRecursive, but uses RawFilePaths
|
||||
listFilesRecursiveBS :: RawFilePath -> IO [RawFilePath]
|
||||
listFilesRecursiveBS topdir = do
|
||||
names <- getDirectoryContentsBS topdir
|
||||
let properNames = filter (`notElem` [".", ".."]) names
|
||||
paths <- forM properNames $ \name -> unsafeInterleaveIO $ do
|
||||
let path = PosixBS.combine topdir name
|
||||
isDir <- isDirectory <$> getFileStatus path
|
||||
if isDir
|
||||
then listFilesRecursiveBS path
|
||||
else return [path]
|
||||
return (topdir : concat paths)
|
||||
----------------------------------------------------------
|
||||
|
||||
|
||||
benchTraverse :: RawFilePath -> IO ()
|
||||
benchTraverse = traverseDirectory (\() p -> BS.putStrLn p) ()
|
||||
|
||||
main :: IO ()
|
||||
main = do
|
||||
args <- getArgs
|
||||
let (d,otherArgs) = case args of
|
||||
[] -> ("/usr/local",[])
|
||||
x:xs -> (x,xs)
|
||||
withArgs otherArgs $ defaultMain
|
||||
[ bench "traverse (FilePath)" $ nfIO $ listFilesRecursive d >>= mapM_ putStrLn
|
||||
, bench "traverse (RawFilePath)" $ nfIO $ listFilesRecursiveBS (BS.pack d) >>= mapM_ BS.putStrLn
|
||||
, bench "allDirectoryContents" $ nfIO $ allDirectoryContents (BS.pack d) >>= mapM_ BS.putStrLn
|
||||
, bench "allDirectoryContents'" $ nfIO $ allDirectoryContents' (BS.pack d) >>= mapM_ BS.putStrLn
|
||||
, bench "traverseDirectory" $ nfIO $ benchTraverse (BS.pack d)
|
||||
, bench "unix find" $ nfIO $ void $ system ("find " ++ d)
|
||||
]
|
|
@ -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
|
|
@ -1,13 +0,0 @@
|
|||
module Main where
|
||||
|
||||
|
||||
import Test.DocTest
|
||||
import Test.HUnit
|
||||
|
||||
main =
|
||||
doctest
|
||||
["-isrc"
|
||||
, "-XOverloadedStrings"
|
||||
, "src/HPath.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
|
||||
]
|
|
@ -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.
|
|
@ -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.
|
|
@ -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
|
|
@ -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
|
File diff suppressed because it is too large
Load Diff
|
@ -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
|
|
@ -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
|
||||
|
||||
|
|
@ -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
|
|
@ -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)
|
|
@ -0,0 +1,78 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CanonicalizePathSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "CanonicalizePathSpec"
|
||||
createTmpDir
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "file"
|
||||
createDir' "dir"
|
||||
createSymlink' "dirSym" "dir/"
|
||||
createSymlink' "brokenSym" "nothing"
|
||||
createSymlink' "fileSym" "file"
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
deleteFile' "file"
|
||||
deleteDir' "dir"
|
||||
deleteFile' "dirSym"
|
||||
deleteFile' "brokenSym"
|
||||
deleteFile' "fileSym"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.canonicalizePath" $ do
|
||||
|
||||
-- successes --
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withTmpDir "file" return
|
||||
canonicalizePath' "file"
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withTmpDir "dir" return
|
||||
canonicalizePath' "dir"
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withTmpDir "file" return
|
||||
canonicalizePath' "fileSym"
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withTmpDir "dir" return
|
||||
canonicalizePath' "dirSym"
|
||||
`shouldReturn` path
|
||||
|
||||
|
||||
-- posix failures --
|
||||
it "canonicalizePath, broken symlink" $
|
||||
canonicalizePath' "brokenSym"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "canonicalizePath, file does not exist" $
|
||||
canonicalizePath' "nothingBlah"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -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
|
|
@ -0,0 +1,181 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CopyDirRecursiveSpec 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 "CopyDirRecursiveSpec"
|
||||
createTmpDir
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "alreadyExists"
|
||||
createRegularFile' "wrongInput"
|
||||
createSymlink' "wrongInputSymL" "inputDir/"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerm"
|
||||
|
||||
createDir' "inputDir"
|
||||
createDir' "inputDir/bar"
|
||||
createDir' "inputDir/foo"
|
||||
createRegularFile' "inputDir/foo/inputFile1"
|
||||
createRegularFile' "inputDir/inputFile2"
|
||||
createRegularFile' "inputDir/bar/inputFile3"
|
||||
writeFile' "inputDir/foo/inputFile1" "SDAADSdsada"
|
||||
writeFile' "inputDir/inputFile2" "Blahfaselgagaga"
|
||||
writeFile' "inputDir/bar/inputFile3"
|
||||
"fdfdssdffsd3223sasdasdasdadasasddasdasdasasd4"
|
||||
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerm"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerm"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteFile' "wrongInput"
|
||||
deleteFile' "wrongInputSymL"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerm"
|
||||
deleteFile' "inputDir/foo/inputFile1"
|
||||
deleteFile' "inputDir/inputFile2"
|
||||
deleteFile' "inputDir/bar/inputFile3"
|
||||
deleteDir' "inputDir/foo"
|
||||
deleteDir' "inputDir/bar"
|
||||
deleteDir' "inputDir"
|
||||
|
||||
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.copyDirRecursive" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyDirRecursive (Strict, FailEarly), all fine" $ do
|
||||
copyDirRecursive' "inputDir"
|
||||
"outputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
removeDirIfExists "outputDir"
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), all fine and compare" $ do
|
||||
tmpDir' <- getRawTmpDir
|
||||
copyDirRecursive' "inputDir"
|
||||
"outputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
(system $ "diff -r "
|
||||
++ toString tmpDir' ++ "inputDir" ++ " "
|
||||
++ toString tmpDir' ++ "outputDir"
|
||||
++ " >/dev/null")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeDirIfExists "outputDir"
|
||||
|
||||
-- posix failures --
|
||||
it "copyDirRecursive (Strict, FailEarly), source directory does not exist" $
|
||||
copyDirRecursive' "doesNotExist"
|
||||
"outputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), no write permission on output dir" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"noWritePerm/foo"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), cannot open output dir" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"noPerms/foo"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), cannot open source dir" $
|
||||
copyDirRecursive' "noPerms/inputDir"
|
||||
"foo"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), destination dir already exists" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"alreadyExistsD"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), destination already exists and is a file" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"alreadyExists"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), wrong input (regular file)" $
|
||||
copyDirRecursive' "wrongInput"
|
||||
"outputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), wrong input (symlink to directory)" $
|
||||
copyDirRecursive' "wrongInputSymL"
|
||||
"outputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
-- custom failures
|
||||
it "copyDirRecursive (Strict, FailEarly), destination in source" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"inputDir/foo"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
isDestinationInSource
|
||||
|
||||
it "copyDirRecursive (Strict, FailEarly), destination and source same directory" $
|
||||
copyDirRecursive' "inputDir"
|
||||
"inputDir"
|
||||
Strict
|
||||
FailEarly
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CopyFileOverwriteSpec 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 "CopyFileOverwriteSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "inputFile"
|
||||
createRegularFile' "alreadyExists"
|
||||
createSymlink' "inputFileSymL" "inputFile"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "noPerms"
|
||||
createRegularFile' "noPerms/inputFile"
|
||||
createDir' "outputDirNoWrite"
|
||||
createDir' "wrongInput"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "outputDirNoWrite"
|
||||
writeFile' "inputFile" "Blahfaselgagaga"
|
||||
writeFile' "alreadyExists" "dsaldsalkaklsdlkasksdadasl"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "outputDirNoWrite"
|
||||
deleteFile' "noPerms/inputFile"
|
||||
deleteFile' "inputFile"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteFile' "inputFileSymL"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "outputDirNoWrite"
|
||||
deleteDir' "wrongInput"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.copyFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyFile (Overwrite), everything clear" $ do
|
||||
copyFile' "inputFile"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
removeFileIfExists "outputFile"
|
||||
|
||||
it "copyFile (Overwrite), output file already exists, all clear" $ do
|
||||
tmpDir' <- getRawTmpDir
|
||||
copyFile' "alreadyExists" "alreadyExists.bak" Strict
|
||||
copyFile' "inputFile" "alreadyExists" Overwrite
|
||||
(system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
|
||||
++ toString tmpDir' ++ "alreadyExists")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists "alreadyExists"
|
||||
copyFile' "alreadyExists.bak" "alreadyExists" Strict
|
||||
removeFileIfExists "alreadyExists.bak"
|
||||
|
||||
it "copyFile (Overwrite), and compare" $ do
|
||||
tmpDir' <- getRawTmpDir
|
||||
copyFile' "inputFile"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
(system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
|
||||
++ toString tmpDir' ++ "outputFile")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists "outputFile"
|
||||
|
||||
|
||||
-- posix failures --
|
||||
it "copyFile (Overwrite), input file does not exist" $
|
||||
copyFile' "noSuchFile"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyFile (Overwrite), no permission to write to output directory" $
|
||||
copyFile' "inputFile"
|
||||
"outputDirNoWrite/outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Overwrite), cannot open output directory" $
|
||||
copyFile' "inputFile"
|
||||
"noPerms/outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Overwrite), cannot open source directory" $
|
||||
copyFile' "noPerms/inputFile"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Overwrite), wrong input type (symlink)" $
|
||||
copyFile' "inputFileSymL"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "copyFile (Overwrite), wrong input type (directory)" $
|
||||
copyFile' "wrongInput"
|
||||
"outputFile"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyFile (Overwrite), output file already exists and is a dir" $
|
||||
copyFile' "inputFile"
|
||||
"alreadyExistsD"
|
||||
Overwrite
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
-- custom failures --
|
||||
it "copyFile (Overwrite), output and input are same file" $
|
||||
copyFile' "inputFile"
|
||||
"inputFile"
|
||||
Overwrite
|
||||
`shouldThrow` isSameFile
|
|
@ -0,0 +1,143 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CopyFileSpec 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 "CopyFileSpec"
|
||||
createTmpDir
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "inputFile"
|
||||
createRegularFile' "alreadyExists"
|
||||
createSymlink' "inputFileSymL" "inputFile"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "noPerms"
|
||||
createRegularFile' "noPerms/inputFile"
|
||||
createDir' "outputDirNoWrite"
|
||||
createDir' "wrongInput"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "outputDirNoWrite"
|
||||
writeFile' "inputFile" "Blahfaselgagaga"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "outputDirNoWrite"
|
||||
deleteFile' "noPerms/inputFile"
|
||||
deleteFile' "inputFile"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteFile' "inputFileSymL"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "outputDirNoWrite"
|
||||
deleteDir' "wrongInput"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.copyFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyFile (Strict), everything clear" $ do
|
||||
copyFile' "inputFile"
|
||||
"outputFile"
|
||||
Strict
|
||||
removeFileIfExists "outputFile"
|
||||
|
||||
it "copyFile (Strict), and compare" $ do
|
||||
tmpDir' <- getRawTmpDir
|
||||
copyFile' "inputFile"
|
||||
"outputFile"
|
||||
Strict
|
||||
(system $ "cmp -s " ++ toString tmpDir' ++ "inputFile" ++ " "
|
||||
++ toString tmpDir' ++ "outputFile")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists "outputFile"
|
||||
|
||||
-- posix failures --
|
||||
it "copyFile (Strict), input file does not exist" $
|
||||
copyFile' "noSuchFile"
|
||||
"outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyFile (Strict), no permission to write to output directory" $
|
||||
copyFile' "inputFile"
|
||||
"outputDirNoWrite/outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Strict), cannot open output directory" $
|
||||
copyFile' "inputFile"
|
||||
"noPerms/outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Strict), cannot open source directory" $
|
||||
copyFile' "noPerms/inputFile"
|
||||
"outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile (Strict), wrong input type (symlink)" $
|
||||
copyFile' "inputFileSymL"
|
||||
"outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "copyFile (Strict), wrong input type (directory)" $
|
||||
copyFile' "wrongInput"
|
||||
"outputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyFile (Strict), output file already exists" $
|
||||
copyFile' "inputFile"
|
||||
"alreadyExists"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyFile (Strict), output file already exists and is a dir" $
|
||||
copyFile' "inputFile"
|
||||
"alreadyExistsD"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
-- custom failures --
|
||||
it "copyFile (Strict), output and input are same file" $
|
||||
copyFile' "inputFile"
|
||||
"inputFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
isSameFile
|
|
@ -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)
|
|
@ -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)
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CreateDirSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "CreateDirSpec"
|
||||
createTmpDir
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createDir' "alreadyExists"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerms"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerms"
|
||||
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerms"
|
||||
deleteDir' "alreadyExists"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerms"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.createDir" $ do
|
||||
|
||||
-- successes --
|
||||
it "createDir, all fine" $ do
|
||||
createDir' "newDir"
|
||||
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`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createDir, can't open output directory" $
|
||||
createDir' "noPerms/newDir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createDir, destination directory already exists" $
|
||||
createDir' "alreadyExists"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CreateRegularFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "CreateRegularFileSpec"
|
||||
createTmpDir
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "alreadyExists"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerms"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerms"
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerms"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerms"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.createRegularFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "createRegularFile, all fine" $ do
|
||||
createRegularFile' "newDir"
|
||||
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`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createRegularFile, can't write to destination directory" $
|
||||
createRegularFile' "noPerms/newDir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createRegularFile, destination file already exists" $
|
||||
createRegularFile' "alreadyExists"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.CreateSymlinkSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "CreateSymlinkSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "alreadyExists"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerms"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerms"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerms"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerms"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.createSymlink" $ do
|
||||
|
||||
-- successes --
|
||||
it "createSymlink, all fine" $ do
|
||||
createSymlink' "newSymL" "alreadyExists/"
|
||||
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`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createSymlink, can't write to destination directory" $
|
||||
createSymlink' "noPerms/newDir" "lala"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createSymlink, destination file already exists" $
|
||||
createSymlink' "alreadyExists" "lala"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.DeleteDirRecursiveSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "DeleteDirRecursiveSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "file"
|
||||
createDir' "dir"
|
||||
createRegularFile' "dir/.keep"
|
||||
createSymlink' "dirSym" "dir/"
|
||||
createDir' "noPerms"
|
||||
createRegularFile' "noPerms/.keep"
|
||||
createDir' "noWritable"
|
||||
createRegularFile' "noWritable/.keep"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
deleteFile' "file"
|
||||
deleteFile' "dir/.keep"
|
||||
deleteDir' "dir"
|
||||
deleteFile' "dirSym"
|
||||
deleteFile' "noPerms/.keep"
|
||||
deleteDir' "noPerms"
|
||||
deleteFile' "noWritable/.keep"
|
||||
deleteDir' "noWritable"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.deleteDirRecursive" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteDirRecursive, empty directory, all fine" $ do
|
||||
createDir' "testDir"
|
||||
deleteDirRecursive' "testDir"
|
||||
getSymbolicLinkStatus "testDir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDirRecursive, empty directory with null permissions, all fine" $ do
|
||||
createDir' "noPerms/testDir"
|
||||
noPerms "noPerms/testDir"
|
||||
deleteDirRecursive' "noPerms/testDir"
|
||||
|
||||
it "deleteDirRecursive, non-empty directory, all fine" $ do
|
||||
createDir' "nonEmpty"
|
||||
createDir' "nonEmpty/dir1"
|
||||
createDir' "nonEmpty/dir2"
|
||||
createDir' "nonEmpty/dir2/dir3"
|
||||
createRegularFile' "nonEmpty/file1"
|
||||
createRegularFile' "nonEmpty/dir1/file2"
|
||||
deleteDirRecursive' "nonEmpty"
|
||||
getSymbolicLinkStatus "nonEmpty"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteDirRecursive, can't open parent directory" $ do
|
||||
createDir' "noPerms/foo"
|
||||
noPerms "noPerms"
|
||||
(deleteDirRecursive' "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
normalDirPerms "noPerms"
|
||||
deleteDir' "noPerms/foo"
|
||||
|
||||
it "deleteDirRecursive, can't write to parent directory" $ do
|
||||
createDir' "noWritable/foo"
|
||||
noWritableDirPerms "noWritable"
|
||||
(deleteDirRecursive' "noWritable/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
normalDirPerms "noWritable"
|
||||
deleteDir' "noWritable/foo"
|
||||
|
||||
it "deleteDirRecursive, wrong file type (symlink to directory)" $
|
||||
deleteDirRecursive' "dirSym"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDirRecursive, wrong file type (regular file)" $
|
||||
deleteDirRecursive' "file"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDirRecursive, directory does not exist" $
|
||||
deleteDirRecursive' "doesNotExist"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
|
|
@ -0,0 +1,114 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.DeleteDirSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "DeleteDirSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "file"
|
||||
createDir' "dir"
|
||||
createRegularFile' "dir/.keep"
|
||||
createSymlink' "dirSym" "dir/"
|
||||
createDir' "noPerms"
|
||||
createRegularFile' "noPerms/.keep"
|
||||
createDir' "noWritable"
|
||||
createRegularFile' "noWritable/.keep"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
deleteFile' "file"
|
||||
deleteFile' "dir/.keep"
|
||||
deleteDir' "dir"
|
||||
deleteFile' "dirSym"
|
||||
deleteFile' "noPerms/.keep"
|
||||
deleteDir' "noPerms"
|
||||
deleteFile' "noWritable/.keep"
|
||||
deleteDir' "noWritable"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.deleteDir" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteDir, empty directory, all fine" $ do
|
||||
createDir' "testDir"
|
||||
deleteDir' "testDir"
|
||||
getSymbolicLinkStatus "testDir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDir, directory with null permissions, all fine" $ do
|
||||
createDir' "noPerms/testDir"
|
||||
noPerms "noPerms/testDir"
|
||||
deleteDir' "noPerms/testDir"
|
||||
getSymbolicLinkStatus "testDir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteDir, wrong file type (symlink to directory)" $
|
||||
deleteDir' "dirSym"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDir, wrong file type (regular file)" $
|
||||
deleteDir' "file"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDir, directory does not exist" $
|
||||
deleteDir' "doesNotExist"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDir, directory not empty" $
|
||||
deleteDir' "dir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == UnsatisfiedConstraints)
|
||||
|
||||
it "deleteDir, can't open parent directory" $ do
|
||||
createDir' "noPerms/foo"
|
||||
noPerms "noPerms"
|
||||
(deleteDir' "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
normalDirPerms "noPerms"
|
||||
deleteDir' "noPerms/foo"
|
||||
|
||||
it "deleteDir, can't write to parent directory, still fine" $ do
|
||||
createDir' "noWritable/foo"
|
||||
noWritableDirPerms "noWritable"
|
||||
(deleteDir' "noWritable/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
normalDirPerms "noWritable"
|
||||
deleteDir' "noWritable/foo"
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.DeleteFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import "hpath-directory" System.Posix.RawFilePath.Directory
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "DeleteFileSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "foo"
|
||||
createSymlink' "syml" "foo"
|
||||
createDir' "dir"
|
||||
createDir' "noPerms"
|
||||
noPerms "noPerms"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
deleteFile' "foo"
|
||||
deleteFile' "syml"
|
||||
deleteDir' "dir"
|
||||
deleteDir' "noPerms"
|
||||
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.deleteFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteFile, regular file, all fine" $ do
|
||||
createRegularFile' "testFile"
|
||||
deleteFile' "testFile"
|
||||
getSymbolicLinkStatus "testFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteFile, symlink, all fine" $ do
|
||||
recreateSymlink' "syml"
|
||||
"testFile"
|
||||
Strict
|
||||
deleteFile' "testFile"
|
||||
getSymbolicLinkStatus "testFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteFile, wrong file type (directory)" $
|
||||
deleteFile' "dir"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType || ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "deleteFile, file does not exist" $
|
||||
deleteFile' "doesNotExist"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteFile, can't read directory" $
|
||||
deleteFile' "noPerms/blah"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.GetDirsFilesSpec where
|
||||
|
||||
|
||||
import Data.List
|
||||
(
|
||||
sort
|
||||
)
|
||||
import "hpath-directory" System.Posix.RawFilePath.Directory hiding (getDirsFiles')
|
||||
import System.Posix.FilePath
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "GetDirsFilesSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "file"
|
||||
createRegularFile' "Lala"
|
||||
createRegularFile' ".hidden"
|
||||
createSymlink' "syml" "Lala"
|
||||
createDir' "dir"
|
||||
createSymlink' "dirsym" "dir"
|
||||
createDir' "noPerms"
|
||||
noPerms "noPerms"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
deleteFile' "file"
|
||||
deleteFile' "Lala"
|
||||
deleteFile' ".hidden"
|
||||
deleteFile' "syml"
|
||||
deleteDir' "dir"
|
||||
deleteFile' "dirsym"
|
||||
deleteDir' "noPerms"
|
||||
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.getDirsFiles" $ do
|
||||
|
||||
-- successes --
|
||||
it "getDirsFiles, all fine" $
|
||||
withRawTmpDir $ \p -> do
|
||||
let expectedFiles = [".hidden"
|
||||
,"Lala"
|
||||
,"dir"
|
||||
,"dirsym"
|
||||
,"file"
|
||||
,"noPerms"
|
||||
,"syml"]
|
||||
(fmap sort $ getDirsFiles p)
|
||||
`shouldReturn` fmap (p </>) expectedFiles
|
||||
|
||||
-- posix failures --
|
||||
it "getDirsFiles, nonexistent directory" $
|
||||
getDirsFiles' "nothingHere"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "getDirsFiles, wrong file type (file)" $
|
||||
getDirsFiles' "file"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "getDirsFiles, wrong file type (symlink to file)" $
|
||||
getDirsFiles' "syml"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "getDirsFiles, wrong file type (symlink to dir)" $
|
||||
getDirsFiles' "dirsym"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "getDirsFiles, can't open directory" $
|
||||
getDirsFiles' "noPerms"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.GetFileTypeSpec where
|
||||
|
||||
|
||||
import "hpath-directory" System.Posix.RawFilePath.Directory
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "GetFileTypeSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "regularfile"
|
||||
createSymlink' "symlink" "regularfile"
|
||||
createSymlink' "brokenSymlink" "broken"
|
||||
createDir' "directory"
|
||||
createSymlink' "symlinkD" "directory"
|
||||
createDir' "noPerms"
|
||||
noPerms "noPerms"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
deleteFile' "regularfile"
|
||||
deleteFile' "symlink"
|
||||
deleteFile' "brokenSymlink"
|
||||
deleteDir' "directory"
|
||||
deleteFile' "symlinkD"
|
||||
deleteDir' "noPerms"
|
||||
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.getFileType" $ do
|
||||
|
||||
-- successes --
|
||||
it "getFileType, regular file" $
|
||||
getFileType' "regularfile"
|
||||
`shouldReturn` RegularFile
|
||||
|
||||
it "getFileType, directory" $
|
||||
getFileType' "directory"
|
||||
`shouldReturn` Directory
|
||||
|
||||
it "getFileType, directory with null permissions" $
|
||||
getFileType' "noPerms"
|
||||
`shouldReturn` Directory
|
||||
|
||||
it "getFileType, symlink to file" $
|
||||
getFileType' "symlink"
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
it "getFileType, symlink to directory" $
|
||||
getFileType' "symlinkD"
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
it "getFileType, broken symlink" $
|
||||
getFileType' "brokenSymlink"
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
-- posix failures --
|
||||
it "getFileType, file does not exist" $
|
||||
getFileType' "nothingHere"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "getFileType, can't open directory" $
|
||||
getFileType' "noPerms/forz"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
|
@ -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
|
|
@ -0,0 +1,129 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.MoveFileSpec 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 "MoveFileSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "myFile"
|
||||
createSymlink' "myFileL" "myFile"
|
||||
createRegularFile' "alreadyExists"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "dir"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerm"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerm"
|
||||
writeFile' "myFile" "Blahfaselgagaga"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerm"
|
||||
deleteFile' "myFile"
|
||||
deleteFile' "myFileL"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "dir"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerm"
|
||||
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.moveFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "moveFile (Strict), all fine" $
|
||||
moveFile' "myFile"
|
||||
"movedFile"
|
||||
Strict
|
||||
|
||||
it "moveFile (Strict), all fine" $
|
||||
moveFile' "myFile"
|
||||
"dir/movedFile"
|
||||
Strict
|
||||
|
||||
it "moveFile (Strict), all fine on symlink" $
|
||||
moveFile' "myFileL"
|
||||
"movedFile"
|
||||
Strict
|
||||
|
||||
it "moveFile (Strict), all fine on directory" $
|
||||
moveFile' "dir"
|
||||
"movedFile"
|
||||
Strict
|
||||
|
||||
-- posix failures --
|
||||
it "moveFile (Strict), source file does not exist" $
|
||||
moveFile' "fileDoesNotExist"
|
||||
"movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "moveFile (Strict), can't write to destination directory" $
|
||||
moveFile' "myFile"
|
||||
"noWritePerm/movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFile (Strict), can't open destination directory" $
|
||||
moveFile' "myFile"
|
||||
"noPerms/movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFile (Strict), can't open source directory" $
|
||||
moveFile' "noPerms/myFile"
|
||||
"movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
-- custom failures --
|
||||
it "moveFile (Strict), destination file already exists" $
|
||||
moveFile' "myFile"
|
||||
"alreadyExists"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "moveFile (Strict), move from file to dir" $
|
||||
moveFile' "myFile"
|
||||
"alreadyExistsD"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "moveFile (Strict), source and dest are same file" $
|
||||
moveFile' "myFile"
|
||||
"myFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
isSameFile
|
|
@ -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)
|
|
@ -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
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.RecreateSymlinkSpec 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 "RecreateSymlinkSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "myFile"
|
||||
createSymlink' "myFileL" "myFile"
|
||||
createRegularFile' "alreadyExists"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "dir"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerm"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerm"
|
||||
writeFile' "myFile" "Blahfaselgagaga"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerm"
|
||||
deleteFile' "myFile"
|
||||
deleteFile' "myFileL"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "dir"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerm"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.recreateSymlink" $ do
|
||||
|
||||
-- successes --
|
||||
it "recreateSymLink (Strict), all fine" $ do
|
||||
recreateSymlink' "myFileL"
|
||||
"movedFile"
|
||||
Strict
|
||||
removeFileIfExists "movedFile"
|
||||
|
||||
it "recreateSymLink (Strict), all fine" $ do
|
||||
recreateSymlink' "myFileL"
|
||||
"dir/movedFile"
|
||||
Strict
|
||||
removeFileIfExists "dir/movedFile"
|
||||
|
||||
-- posix failures --
|
||||
it "recreateSymLink (Strict), wrong input type (file)" $
|
||||
recreateSymlink' "myFile"
|
||||
"movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "recreateSymLink (Strict), wrong input type (directory)" $
|
||||
recreateSymlink' "dir"
|
||||
"movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "recreateSymLink (Strict), can't write to destination directory" $
|
||||
recreateSymlink' "myFileL"
|
||||
"noWritePerm/movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink (Strict), can't open destination directory" $
|
||||
recreateSymlink' "myFileL"
|
||||
"noPerms/movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink (Strict), can't open source directory" $
|
||||
recreateSymlink' "noPerms/myFileL"
|
||||
"movedFile"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink (Strict), destination file already exists" $
|
||||
recreateSymlink' "myFileL"
|
||||
"alreadyExists"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "recreateSymLink (Strict), destination already exists and is a dir" $
|
||||
recreateSymlink' "myFileL"
|
||||
"alreadyExistsD"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
-- custom failures --
|
||||
it "recreateSymLink (Strict), source and destination are the same file" $
|
||||
recreateSymlink' "myFileL"
|
||||
"myFileL"
|
||||
Strict
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
|
@ -0,0 +1,117 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module System.Posix.RawFilePath.Directory.RenameFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.Posix.RawFilePath.Directory.Errors
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
|
||||
|
||||
|
||||
upTmpDir :: IO ()
|
||||
upTmpDir = do
|
||||
setTmpDir "RenameFileSpec"
|
||||
createTmpDir
|
||||
|
||||
|
||||
setupFiles :: IO ()
|
||||
setupFiles = do
|
||||
createRegularFile' "myFile"
|
||||
createSymlink' "myFileL" "myFile"
|
||||
createRegularFile' "alreadyExists"
|
||||
createDir' "alreadyExistsD"
|
||||
createDir' "dir"
|
||||
createDir' "noPerms"
|
||||
createDir' "noWritePerm"
|
||||
noPerms "noPerms"
|
||||
noWritableDirPerms "noWritePerm"
|
||||
writeFile' "myFile" "Blahfaselgagaga"
|
||||
|
||||
|
||||
cleanupFiles :: IO ()
|
||||
cleanupFiles = do
|
||||
normalDirPerms "noPerms"
|
||||
normalDirPerms "noWritePerm"
|
||||
deleteFile' "myFile"
|
||||
deleteFile' "myFileL"
|
||||
deleteFile' "alreadyExists"
|
||||
deleteDir' "alreadyExistsD"
|
||||
deleteDir' "dir"
|
||||
deleteDir' "noPerms"
|
||||
deleteDir' "noWritePerm"
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec = beforeAll_ (upTmpDir >> setupFiles) $ afterAll_ cleanupFiles $
|
||||
describe "System.Posix.RawFilePath.Directory.renameFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "renameFile, all fine" $
|
||||
renameFile' "myFile"
|
||||
"renamedFile"
|
||||
|
||||
it "renameFile, all fine" $
|
||||
renameFile' "myFile"
|
||||
"dir/renamedFile"
|
||||
|
||||
it "renameFile, all fine on symlink" $
|
||||
renameFile' "myFileL"
|
||||
"renamedFile"
|
||||
|
||||
it "renameFile, all fine on directory" $
|
||||
renameFile' "dir"
|
||||
"renamedFile"
|
||||
|
||||
-- posix failures --
|
||||
it "renameFile, source file does not exist" $
|
||||
renameFile' "fileDoesNotExist"
|
||||
"renamedFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "renameFile, can't write to output directory" $
|
||||
renameFile' "myFile"
|
||||
"noWritePerm/renamedFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "renameFile, can't open output directory" $
|
||||
renameFile' "myFile"
|
||||
"noPerms/renamedFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "renameFile, can't open source directory" $
|
||||
renameFile' "noPerms/myFile"
|
||||
"renamedFile"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
-- custom failures --
|
||||
it "renameFile, destination file already exists" $
|
||||
renameFile' "myFile"
|
||||
"alreadyExists"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "renameFile, move from file to dir" $
|
||||
renameFile' "myFile"
|
||||
"alreadyExistsD"
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "renameFile, source and dest are same file" $
|
||||
renameFile' "myFile"
|
||||
"myFile"
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -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)
|
|
@ -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)
|
|
@ -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)
|
||||
|
|
@ -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.
|
|
@ -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.
|
|
@ -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
|
|
@ -0,0 +1,2 @@
|
|||
import Distribution.Simple
|
||||
main = defaultMain
|
|
@ -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
|
|
@ -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
|
|
@ -12,6 +12,7 @@
|
|||
-- Not all functions of "System.FilePath" are implemented yet. Feel free to contribute!
|
||||
|
||||
|
||||
{-# LANGUAGE CPP #-}
|
||||
{-# LANGUAGE TupleSections #-}
|
||||
|
||||
{-# OPTIONS_GHC -Wall #-}
|
||||
|
@ -19,7 +20,7 @@
|
|||
|
||||
module System.Posix.FilePath (
|
||||
|
||||
-- * Separators
|
||||
-- * Separator predicates
|
||||
pathSeparator
|
||||
, isPathSeparator
|
||||
, searchPathSeparator
|
||||
|
@ -27,7 +28,11 @@ module System.Posix.FilePath (
|
|||
, extSeparator
|
||||
, isExtSeparator
|
||||
|
||||
-- * File extensions
|
||||
-- * $PATH methods
|
||||
, splitSearchPath
|
||||
, getSearchPath
|
||||
|
||||
-- * Extension functions
|
||||
, splitExtension
|
||||
, takeExtension
|
||||
, replaceExtension
|
||||
|
@ -38,8 +43,9 @@ module System.Posix.FilePath (
|
|||
, splitExtensions
|
||||
, dropExtensions
|
||||
, takeExtensions
|
||||
, stripExtension
|
||||
|
||||
-- * Filenames/Directory names
|
||||
-- * Filename\/directory functions
|
||||
, splitFileName
|
||||
, takeFileName
|
||||
, replaceFileName
|
||||
|
@ -48,29 +54,29 @@ module System.Posix.FilePath (
|
|||
, replaceBaseName
|
||||
, takeDirectory
|
||||
, replaceDirectory
|
||||
|
||||
-- * Path combinators and splitters
|
||||
, combine
|
||||
, (</>)
|
||||
, splitPath
|
||||
, joinPath
|
||||
, splitDirectories
|
||||
, takeAllParents
|
||||
|
||||
-- * Path conversions
|
||||
, normalise
|
||||
|
||||
-- * Trailing path separator
|
||||
-- * Trailing slash functions
|
||||
, hasTrailingPathSeparator
|
||||
, addTrailingPathSeparator
|
||||
, dropTrailingPathSeparator
|
||||
|
||||
-- * Queries
|
||||
-- * File name manipulations
|
||||
, normalise
|
||||
, makeRelative
|
||||
, equalFilePath
|
||||
, isRelative
|
||||
, isAbsolute
|
||||
, isValid
|
||||
, makeValid
|
||||
, isSpecialDirectoryEntry
|
||||
, isFileName
|
||||
, hasParentDir
|
||||
, equalFilePath
|
||||
, hiddenFile
|
||||
|
||||
, module System.Posix.ByteString.FilePath
|
||||
|
@ -78,15 +84,21 @@ module System.Posix.FilePath (
|
|||
|
||||
import Data.ByteString (ByteString)
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.String (fromString)
|
||||
import System.Posix.ByteString.FilePath
|
||||
import qualified System.Posix.Env.ByteString as PE
|
||||
|
||||
import Data.Maybe (isJust)
|
||||
import Data.Word8
|
||||
|
||||
#if !MIN_VERSION_bytestring(0,10,8)
|
||||
import qualified Data.List as L
|
||||
#endif
|
||||
import Control.Arrow (second)
|
||||
|
||||
-- $setup
|
||||
-- >>> import Data.Char
|
||||
-- >>> import Data.Maybe
|
||||
-- >>> import Data.Word8
|
||||
-- >>> import Test.QuickCheck
|
||||
-- >>> import Control.Applicative
|
||||
-- >>> import qualified Data.ByteString as BS
|
||||
|
@ -96,38 +108,84 @@ import Control.Arrow (second)
|
|||
-- >>> let _chr :: Word8 -> Char; _chr = chr . fromIntegral
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
-- Separator predicates
|
||||
|
||||
|
||||
-- | Path separator character
|
||||
pathSeparator :: Word8
|
||||
pathSeparator = _slash
|
||||
|
||||
|
||||
-- | Check if a character is the path separator
|
||||
--
|
||||
-- prop> \n -> (_chr n == '/') == isPathSeparator n
|
||||
isPathSeparator :: Word8 -> Bool
|
||||
isPathSeparator = (== pathSeparator)
|
||||
|
||||
|
||||
-- | Search path separator
|
||||
searchPathSeparator :: Word8
|
||||
searchPathSeparator = _colon
|
||||
|
||||
|
||||
-- | Check if a character is the search path separator
|
||||
--
|
||||
-- prop> \n -> (_chr n == ':') == isSearchPathSeparator n
|
||||
isSearchPathSeparator :: Word8 -> Bool
|
||||
isSearchPathSeparator = (== searchPathSeparator)
|
||||
|
||||
|
||||
-- | File extension separator
|
||||
extSeparator :: Word8
|
||||
extSeparator = _period
|
||||
|
||||
|
||||
-- | Check if a character is the file extension separator
|
||||
--
|
||||
-- prop> \n -> (_chr n == '.') == isExtSeparator n
|
||||
isExtSeparator :: Word8 -> Bool
|
||||
isExtSeparator = (== extSeparator)
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
-- extension stuff
|
||||
-- $PATH methods
|
||||
|
||||
|
||||
-- | Take a ByteString, split it on the 'searchPathSeparator'.
|
||||
-- Blank items are converted to @.@.
|
||||
--
|
||||
-- Follows the recommendations in
|
||||
-- <http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html>
|
||||
--
|
||||
-- >>> splitSearchPath "File1:File2:File3"
|
||||
-- ["File1","File2","File3"]
|
||||
-- >>> splitSearchPath "File1::File2:File3"
|
||||
-- ["File1",".","File2","File3"]
|
||||
-- >>> splitSearchPath ""
|
||||
-- ["."]
|
||||
splitSearchPath :: ByteString -> [RawFilePath]
|
||||
splitSearchPath = f
|
||||
where
|
||||
f bs = let (pre, post) = BS.break isSearchPathSeparator bs
|
||||
in if BS.null post
|
||||
then g pre
|
||||
else g pre ++ f (BS.tail post)
|
||||
g x
|
||||
| BS.null x = [BS.singleton _period]
|
||||
| otherwise = [x]
|
||||
|
||||
|
||||
-- | Get a list of 'RawFilePath's in the $PATH variable.
|
||||
getSearchPath :: IO [RawFilePath]
|
||||
getSearchPath = fmap (maybe [] splitSearchPath) (PE.getEnv $ fromString "PATH")
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
-- Extension functions
|
||||
|
||||
-- | Split a 'RawFilePath' into a path+filename and extension
|
||||
--
|
||||
|
@ -147,6 +205,7 @@ splitExtension x = if BS.null basename
|
|||
(path,file) = splitFileNameRaw x
|
||||
(basename,fileExt) = BS.breakEnd isExtSeparator file
|
||||
|
||||
|
||||
-- | Get the final extension from a 'RawFilePath'
|
||||
--
|
||||
-- >>> takeExtension "file.exe"
|
||||
|
@ -158,12 +217,14 @@ splitExtension x = if BS.null basename
|
|||
takeExtension :: RawFilePath -> ByteString
|
||||
takeExtension = snd . splitExtension
|
||||
|
||||
|
||||
-- | Change a file's extension
|
||||
--
|
||||
-- prop> \path -> let ext = takeExtension path in replaceExtension path ext == path
|
||||
replaceExtension :: RawFilePath -> ByteString -> RawFilePath
|
||||
replaceExtension path ext = dropExtension path <.> ext
|
||||
|
||||
|
||||
-- | Drop the final extension from a 'RawFilePath'
|
||||
--
|
||||
-- >>> dropExtension "file.exe"
|
||||
|
@ -175,6 +236,7 @@ replaceExtension path ext = dropExtension path <.> ext
|
|||
dropExtension :: RawFilePath -> RawFilePath
|
||||
dropExtension = fst . splitExtension
|
||||
|
||||
|
||||
-- | Add an extension to a 'RawFilePath'
|
||||
--
|
||||
-- >>> addExtension "file" ".exe"
|
||||
|
@ -190,10 +252,6 @@ addExtension file ext
|
|||
| otherwise = BS.intercalate (BS.singleton extSeparator) [file, ext]
|
||||
|
||||
|
||||
-- | Operator version of 'addExtension'
|
||||
(<.>) :: RawFilePath -> ByteString -> RawFilePath
|
||||
(<.>) = addExtension
|
||||
|
||||
-- | Check if a 'RawFilePath' has an extension
|
||||
--
|
||||
-- >>> hasExtension "file"
|
||||
|
@ -205,7 +263,13 @@ addExtension file ext
|
|||
hasExtension :: RawFilePath -> Bool
|
||||
hasExtension = isJust . BS.elemIndex extSeparator . takeFileName
|
||||
|
||||
-- | Split a 'RawFilePath' on the first extension
|
||||
|
||||
-- | Operator version of 'addExtension'
|
||||
(<.>) :: RawFilePath -> ByteString -> RawFilePath
|
||||
(<.>) = addExtension
|
||||
|
||||
|
||||
-- | Split a 'RawFilePath' on the first extension.
|
||||
--
|
||||
-- >>> splitExtensions "/path/file.tar.gz"
|
||||
-- ("/path/file",".tar.gz")
|
||||
|
@ -219,6 +283,7 @@ splitExtensions x = if BS.null basename
|
|||
(path,file) = splitFileNameRaw x
|
||||
(basename,fileExt) = BS.break isExtSeparator file
|
||||
|
||||
|
||||
-- | Remove all extensions from a 'RawFilePath'
|
||||
--
|
||||
-- >>> dropExtensions "/path/file.tar.gz"
|
||||
|
@ -226,6 +291,7 @@ splitExtensions x = if BS.null basename
|
|||
dropExtensions :: RawFilePath -> RawFilePath
|
||||
dropExtensions = fst . splitExtensions
|
||||
|
||||
|
||||
-- | Take all extensions from a 'RawFilePath'
|
||||
--
|
||||
-- >>> takeExtensions "/path/file.tar.gz"
|
||||
|
@ -233,8 +299,48 @@ dropExtensions = fst . splitExtensions
|
|||
takeExtensions :: RawFilePath -> ByteString
|
||||
takeExtensions = snd . splitExtensions
|
||||
|
||||
|
||||
-- | Drop the given extension from a FilePath, and the @\".\"@ preceding it.
|
||||
-- Returns 'Nothing' if the FilePath does not have the given extension, or
|
||||
-- 'Just' and the part before the extension if it does.
|
||||
--
|
||||
-- This function can be more predictable than 'dropExtensions',
|
||||
-- especially if the filename might itself contain @.@ characters.
|
||||
--
|
||||
-- >>> stripExtension "hs.o" "foo.x.hs.o"
|
||||
-- Just "foo.x"
|
||||
-- >>> stripExtension "hi.o" "foo.x.hs.o"
|
||||
-- Nothing
|
||||
-- >>> stripExtension ".c.d" "a.b.c.d"
|
||||
-- Just "a.b"
|
||||
-- >>> stripExtension ".c.d" "a.b..c.d"
|
||||
-- Just "a.b."
|
||||
-- >>> stripExtension "baz" "foo.bar"
|
||||
-- Nothing
|
||||
-- >>> stripExtension "bar" "foobar"
|
||||
-- Nothing
|
||||
--
|
||||
-- prop> \path -> stripExtension "" path == Just path
|
||||
-- prop> \path -> dropExtension path == fromJust (stripExtension (takeExtension path) path)
|
||||
-- prop> \path -> dropExtensions path == fromJust (stripExtension (takeExtensions path) path)
|
||||
stripExtension :: ByteString -> RawFilePath -> Maybe RawFilePath
|
||||
stripExtension bs path
|
||||
| BS.null bs = Just path
|
||||
| otherwise = stripSuffix' dotExt path
|
||||
where
|
||||
dotExt = if isExtSeparator $ BS.head bs
|
||||
then bs
|
||||
else extSeparator `BS.cons` bs
|
||||
#if MIN_VERSION_bytestring(0,10,8)
|
||||
stripSuffix' = BS.stripSuffix
|
||||
#else
|
||||
stripSuffix' xs ys = fmap (BS.pack . reverse) $ L.stripPrefix (reverse $ BS.unpack xs) (reverse $ BS.unpack ys)
|
||||
#endif
|
||||
|
||||
|
||||
------------------------
|
||||
-- more stuff
|
||||
-- Filename/directory functions
|
||||
|
||||
|
||||
-- | Split a 'RawFilePath' into (path,file). 'combine' is the inverse
|
||||
--
|
||||
|
@ -264,12 +370,14 @@ splitFileName x = if BS.null path
|
|||
takeFileName :: RawFilePath -> RawFilePath
|
||||
takeFileName = snd . splitFileName
|
||||
|
||||
|
||||
-- | Change the file name
|
||||
--
|
||||
-- prop> \path -> replaceFileName path (takeFileName path) == path
|
||||
replaceFileName :: RawFilePath -> ByteString -> RawFilePath
|
||||
replaceFileName x y = fst (splitFileNameRaw x) </> y
|
||||
|
||||
|
||||
-- | Drop the file name
|
||||
--
|
||||
-- >>> dropFileName "path/file.txt"
|
||||
|
@ -279,6 +387,7 @@ replaceFileName x y = fst (splitFileNameRaw x) </> y
|
|||
dropFileName :: RawFilePath -> RawFilePath
|
||||
dropFileName = fst . splitFileName
|
||||
|
||||
|
||||
-- | Get the file name, without a trailing extension
|
||||
--
|
||||
-- >>> takeBaseName "path/file.tar.gz"
|
||||
|
@ -288,6 +397,7 @@ dropFileName = fst . splitFileName
|
|||
takeBaseName :: RawFilePath -> ByteString
|
||||
takeBaseName = dropExtension . takeFileName
|
||||
|
||||
|
||||
-- | Change the base name
|
||||
--
|
||||
-- >>> replaceBaseName "path/file.tar.gz" "bob"
|
||||
|
@ -300,6 +410,7 @@ replaceBaseName path name = combineRaw dir (name <.> ext)
|
|||
(dir,file) = splitFileNameRaw path
|
||||
ext = takeExtension file
|
||||
|
||||
|
||||
-- | Get the directory, moving up one level if it's already a directory
|
||||
--
|
||||
-- >>> takeDirectory "path/file.txt"
|
||||
|
@ -319,12 +430,14 @@ takeDirectory x = case () of
|
|||
res = fst $ BS.spanEnd isPathSeparator file
|
||||
file = dropFileName x
|
||||
|
||||
|
||||
-- | Change the directory component of a 'RawFilePath'
|
||||
--
|
||||
-- prop> \path -> replaceDirectory path (takeDirectory path) `equalFilePath` path || takeDirectory path == "."
|
||||
replaceDirectory :: RawFilePath -> ByteString -> RawFilePath
|
||||
replaceDirectory file dir = combineRaw dir (takeFileName file)
|
||||
|
||||
|
||||
-- | Join two paths together
|
||||
--
|
||||
-- >>> combine "/" "file"
|
||||
|
@ -337,6 +450,7 @@ combine :: RawFilePath -> RawFilePath -> RawFilePath
|
|||
combine a b | not (BS.null b) && isPathSeparator (BS.head b) = b
|
||||
| otherwise = combineRaw a b
|
||||
|
||||
|
||||
-- | Operator version of combine
|
||||
(</>) :: RawFilePath -> RawFilePath -> RawFilePath
|
||||
(</>) = combine
|
||||
|
@ -358,10 +472,23 @@ splitPath = splitter
|
|||
Nothing -> [x]
|
||||
Just runlen -> uncurry (:) . second splitter $ BS.splitAt (ix+1+runlen) x
|
||||
|
||||
|
||||
-- | Join a split path back together
|
||||
--
|
||||
-- prop> \path -> joinPath (splitPath path) == path
|
||||
--
|
||||
-- >>> joinPath ["path","to","file.txt"]
|
||||
-- "path/to/file.txt"
|
||||
joinPath :: [RawFilePath] -> RawFilePath
|
||||
joinPath = foldr (</>) BS.empty
|
||||
|
||||
|
||||
-- | Like 'splitPath', but without trailing slashes
|
||||
--
|
||||
-- >>> splitDirectories "/path/to/file.txt"
|
||||
-- ["/","path","to","file.txt"]
|
||||
-- >>> splitDirectories "path/to/file.txt"
|
||||
-- ["path","to","file.txt"]
|
||||
-- >>> splitDirectories ""
|
||||
-- []
|
||||
splitDirectories :: RawFilePath -> [RawFilePath]
|
||||
|
@ -373,14 +500,75 @@ splitDirectories x
|
|||
where
|
||||
splitter = filter (not . BS.null) . BS.split pathSeparator
|
||||
|
||||
-- | Join a split path back together
|
||||
|
||||
-- |Get all parents of a path.
|
||||
--
|
||||
-- prop> \path -> joinPath (splitPath path) == 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
|
||||
|
||||
-- | Check if the last character of a 'RawFilePath' is '/'.
|
||||
--
|
||||
-- >>> joinPath ["path","to","file.txt"]
|
||||
-- "path/to/file.txt"
|
||||
joinPath :: [RawFilePath] -> RawFilePath
|
||||
joinPath = foldr (</>) BS.empty
|
||||
-- >>> hasTrailingPathSeparator "/path/"
|
||||
-- True
|
||||
-- >>> hasTrailingPathSeparator "/"
|
||||
-- True
|
||||
-- >>> hasTrailingPathSeparator "/path"
|
||||
-- False
|
||||
hasTrailingPathSeparator :: RawFilePath -> Bool
|
||||
hasTrailingPathSeparator x
|
||||
| BS.null x = False
|
||||
| otherwise = isPathSeparator $ BS.last x
|
||||
|
||||
|
||||
-- | Add a trailing path separator.
|
||||
--
|
||||
-- >>> addTrailingPathSeparator "/path"
|
||||
-- "/path/"
|
||||
-- >>> addTrailingPathSeparator "/path/"
|
||||
-- "/path/"
|
||||
-- >>> addTrailingPathSeparator "/"
|
||||
-- "/"
|
||||
addTrailingPathSeparator :: RawFilePath -> RawFilePath
|
||||
addTrailingPathSeparator x = if hasTrailingPathSeparator x
|
||||
then x
|
||||
else x `BS.snoc` pathSeparator
|
||||
|
||||
|
||||
-- | Remove a trailing path separator
|
||||
--
|
||||
-- >>> dropTrailingPathSeparator "/path/"
|
||||
-- "/path"
|
||||
-- >>> dropTrailingPathSeparator "/path////"
|
||||
-- "/path"
|
||||
-- >>> dropTrailingPathSeparator "/"
|
||||
-- "/"
|
||||
-- >>> dropTrailingPathSeparator "//"
|
||||
-- "/"
|
||||
dropTrailingPathSeparator :: RawFilePath -> RawFilePath
|
||||
dropTrailingPathSeparator x
|
||||
| x == BS.singleton pathSeparator = x
|
||||
| otherwise = if hasTrailingPathSeparator x
|
||||
then dropTrailingPathSeparator $ BS.init x
|
||||
else x
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
-- File name manipulations
|
||||
|
||||
|
||||
-- |Normalise a file.
|
||||
|
@ -436,54 +624,80 @@ normalise filepath =
|
|||
dropDots :: [ByteString] -> [ByteString]
|
||||
dropDots = filter (BS.singleton _period /=)
|
||||
|
||||
------------------------
|
||||
-- trailing path separators
|
||||
|
||||
-- | Check if the last character of a 'RawFilePath' is '/'.
|
||||
|
||||
-- | Contract a filename, based on a relative path. Note that the resulting
|
||||
-- path will never introduce @..@ paths, as the presence of symlinks
|
||||
-- means @..\/b@ may not reach @a\/b@ if it starts from @a\/c@. For a
|
||||
-- worked example see
|
||||
-- <http://neilmitchell.blogspot.co.uk/2015/10/filepaths-are-subtle-symlinks-are-hard.html this blog post>.
|
||||
--
|
||||
-- >>> hasTrailingPathSeparator "/path/"
|
||||
-- >>> makeRelative "/directory" "/directory/file.ext"
|
||||
-- "file.ext"
|
||||
-- >>> makeRelative "/Home" "/home/bob"
|
||||
-- "/home/bob"
|
||||
-- >>> makeRelative "/home/" "/home/bob/foo/bar"
|
||||
-- "bob/foo/bar"
|
||||
-- >>> makeRelative "/fred" "bob"
|
||||
-- "bob"
|
||||
-- >>> makeRelative "/file/test" "/file/test/fred"
|
||||
-- "fred"
|
||||
-- >>> makeRelative "/file/test" "/file/test/fred/"
|
||||
-- "fred/"
|
||||
-- >>> makeRelative "some/path" "some/path/a/b/c"
|
||||
-- "a/b/c"
|
||||
--
|
||||
-- prop> \p -> makeRelative p p == "."
|
||||
-- prop> \p -> makeRelative (takeDirectory p) p `equalFilePath` takeFileName p
|
||||
-- prop \x y -> equalFilePath x y || (isRelative x && makeRelative y x == x) || equalFilePath (y </> makeRelative y x) x
|
||||
makeRelative :: RawFilePath -> RawFilePath -> RawFilePath
|
||||
makeRelative root path
|
||||
| equalFilePath root path = BS.singleton _period
|
||||
| takeAbs root /= takeAbs path = path
|
||||
| otherwise = f (dropAbs root) (dropAbs path)
|
||||
where
|
||||
f x y
|
||||
| BS.null x = BS.dropWhile isPathSeparator y
|
||||
| otherwise = let (x1,x2) = g x
|
||||
(y1,y2) = g y
|
||||
in if equalFilePath x1 y1 then f x2 y2 else path
|
||||
g x = (BS.dropWhile isPathSeparator a, BS.dropWhile isPathSeparator b)
|
||||
where (a, b) = BS.break isPathSeparator $ BS.dropWhile isPathSeparator x
|
||||
dropAbs x = snd $ BS.span (== _slash) x
|
||||
takeAbs x = fst $ BS.span (== _slash) x
|
||||
|
||||
|
||||
-- |Equality of two filepaths. The filepaths are normalised
|
||||
-- and trailing path separators are dropped.
|
||||
--
|
||||
-- >>> equalFilePath "foo" "foo"
|
||||
-- True
|
||||
-- >>> hasTrailingPathSeparator "/"
|
||||
-- >>> equalFilePath "foo" "foo/"
|
||||
-- True
|
||||
-- >>> hasTrailingPathSeparator "/path"
|
||||
-- >>> equalFilePath "foo" "./foo"
|
||||
-- True
|
||||
-- >>> equalFilePath "" ""
|
||||
-- True
|
||||
-- >>> equalFilePath "foo" "/foo"
|
||||
-- False
|
||||
-- >>> equalFilePath "foo" "FOO"
|
||||
-- False
|
||||
-- >>> equalFilePath "foo" "../foo"
|
||||
-- False
|
||||
hasTrailingPathSeparator :: RawFilePath -> Bool
|
||||
hasTrailingPathSeparator x
|
||||
| BS.null x = False
|
||||
| otherwise = isPathSeparator $ BS.last x
|
||||
|
||||
-- | Add a trailing path separator.
|
||||
--
|
||||
-- >>> addTrailingPathSeparator "/path"
|
||||
-- "/path/"
|
||||
-- >>> addTrailingPathSeparator "/path/"
|
||||
-- "/path/"
|
||||
-- >>> addTrailingPathSeparator "/"
|
||||
-- "/"
|
||||
addTrailingPathSeparator :: RawFilePath -> RawFilePath
|
||||
addTrailingPathSeparator x = if hasTrailingPathSeparator x
|
||||
then x
|
||||
else x `BS.snoc` pathSeparator
|
||||
-- prop> \p -> equalFilePath p p
|
||||
equalFilePath :: RawFilePath -> RawFilePath -> Bool
|
||||
equalFilePath p1 p2 = f p1 == f p2
|
||||
where
|
||||
f x = dropTrailingPathSeparator $ normalise x
|
||||
|
||||
-- | Remove a trailing path separator
|
||||
|
||||
-- | Check if a path is relative
|
||||
--
|
||||
-- >>> dropTrailingPathSeparator "/path/"
|
||||
-- "/path"
|
||||
-- >>> dropTrailingPathSeparator "/path////"
|
||||
-- "/path"
|
||||
-- >>> dropTrailingPathSeparator "/"
|
||||
-- "/"
|
||||
-- >>> dropTrailingPathSeparator "//"
|
||||
-- "/"
|
||||
dropTrailingPathSeparator :: RawFilePath -> RawFilePath
|
||||
dropTrailingPathSeparator x
|
||||
| x == BS.singleton pathSeparator = x
|
||||
| otherwise = if hasTrailingPathSeparator x
|
||||
then dropTrailingPathSeparator $ BS.init x
|
||||
else x
|
||||
-- prop> \path -> isRelative path /= isAbsolute path
|
||||
isRelative :: RawFilePath -> Bool
|
||||
isRelative = not . isAbsolute
|
||||
|
||||
------------------------
|
||||
-- Filename/system stuff
|
||||
|
||||
-- | Check if a path is absolute
|
||||
--
|
||||
|
@ -498,11 +712,6 @@ isAbsolute x
|
|||
| BS.length x > 0 = isPathSeparator (BS.head x)
|
||||
| otherwise = False
|
||||
|
||||
-- | Check if a path is relative
|
||||
--
|
||||
-- prop> \path -> isRelative path /= isAbsolute path
|
||||
isRelative :: RawFilePath -> Bool
|
||||
isRelative = not . isAbsolute
|
||||
|
||||
-- | Is a FilePath valid, i.e. could you create a file like it?
|
||||
--
|
||||
|
@ -518,6 +727,38 @@ isValid filepath
|
|||
| _nul `BS.elem` filepath = False
|
||||
| otherwise = True
|
||||
|
||||
|
||||
-- | Take a FilePath and make it valid; does not change already valid FilePaths.
|
||||
--
|
||||
-- >>> makeValid ""
|
||||
-- "_"
|
||||
-- >>> makeValid "file\0name"
|
||||
-- "file_name"
|
||||
--
|
||||
-- prop> \p -> if isValid p then makeValid p == p else makeValid p /= p
|
||||
-- prop> \p -> isValid (makeValid p)
|
||||
makeValid :: RawFilePath -> RawFilePath
|
||||
makeValid path
|
||||
| BS.null path = BS.singleton _underscore
|
||||
| otherwise = BS.map (\x -> if x == _nul then _underscore else x) path
|
||||
|
||||
|
||||
-- | 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 "..".
|
||||
--
|
||||
|
@ -539,6 +780,7 @@ isFileName filepath =
|
|||
not (BS.null filepath) &&
|
||||
not (_nul `BS.elem` filepath)
|
||||
|
||||
|
||||
-- | Check if the filepath has any parent directories in it.
|
||||
--
|
||||
-- >>> hasParentDir "/.."
|
||||
|
@ -570,28 +812,6 @@ hasParentDir filepath =
|
|||
where
|
||||
pathDoubleDot = BS.pack [_period, _period]
|
||||
|
||||
-- |Equality of two filepaths. The filepaths are normalised
|
||||
-- and trailing path separators are dropped.
|
||||
--
|
||||
-- >>> equalFilePath "foo" "foo"
|
||||
-- True
|
||||
-- >>> equalFilePath "foo" "foo/"
|
||||
-- True
|
||||
-- >>> equalFilePath "foo" "./foo"
|
||||
-- True
|
||||
-- >>> equalFilePath "foo" "/foo"
|
||||
-- False
|
||||
-- >>> equalFilePath "foo" "FOO"
|
||||
-- False
|
||||
-- >>> equalFilePath "foo" "../foo"
|
||||
-- False
|
||||
--
|
||||
-- prop> \p -> equalFilePath p p
|
||||
equalFilePath :: RawFilePath -> RawFilePath -> Bool
|
||||
equalFilePath p1 p2 = f p1 == f p2
|
||||
where
|
||||
f x = dropTrailingPathSeparator $ normalise x
|
||||
|
||||
|
||||
-- | Whether the file is a hidden file.
|
||||
--
|
||||
|
@ -620,6 +840,8 @@ hiddenFile fp
|
|||
where
|
||||
fn = takeFileName fp
|
||||
|
||||
|
||||
|
||||
------------------------
|
||||
-- internal stuff
|
||||
|
|
@ -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
|
|
@ -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.
|
|
@ -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.
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
import Distribution.Simple
|
||||
main = defaultMain
|
|
@ -0,0 +1,6 @@
|
|||
# TODO
|
||||
|
||||
## Tests
|
||||
|
||||
* `doesExist` not tested
|
||||
* `readFileStream` only implicitly tested by `readFile`
|
|
@ -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
|
|
@ -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)
|
|
@ -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.
|
|
@ -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.
|
|
@ -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)
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
import Distribution.Simple
|
||||
main = defaultMain
|
|
@ -1,7 +1,7 @@
|
|||
#include "dirutils.h"
|
||||
|
||||
unsigned int
|
||||
__posixdir_d_type(struct dirent* d)
|
||||
{
|
||||
return(d -> d_type);
|
||||
}
|
||||
|
|
@ -7,7 +7,9 @@
|
|||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
|
||||
extern unsigned int
|
||||
__posixdir_d_type(struct dirent* d)
|
||||
;
|
||||
|
||||
#endif
|
|
@ -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
|
|
@ -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
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
module System.Posix.Directory.Foreign where
|
||||
module System.Posix.Foreign where
|
||||
|
||||
import Data.Bits
|
||||
import Data.List (foldl')
|
|
@ -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
|
123
hpath.cabal
123
hpath.cabal
|
@ -1,123 +0,0 @@
|
|||
name: hpath
|
||||
version: 0.7.0
|
||||
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
|
||||
benchmarks/*.hs
|
||||
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,
|
||||
HPath.Internal,
|
||||
System.Posix.Directory.Foreign,
|
||||
System.Posix.Directory.Traversals,
|
||||
System.Posix.FD,
|
||||
System.Posix.FilePath
|
||||
build-depends: base >= 4.2 && <5
|
||||
, bytestring >= 0.9.2.0
|
||||
, deepseq
|
||||
, exceptions
|
||||
, hspec
|
||||
, simple-sendfile >= 0.2.22
|
||||
, 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:
|
||||
Spec
|
||||
HPath.IO.CopyDirRecursiveSpec
|
||||
HPath.IO.CopyDirRecursiveOverwriteSpec
|
||||
HPath.IO.CopyFileSpec
|
||||
HPath.IO.CopyFileOverwriteSpec
|
||||
HPath.IO.CreateDirSpec
|
||||
HPath.IO.CreateRegularFileSpec
|
||||
HPath.IO.DeleteDirRecursiveSpec
|
||||
HPath.IO.DeleteDirSpec
|
||||
HPath.IO.DeleteFileSpec
|
||||
HPath.IO.GetDirsFilesSpec
|
||||
HPath.IO.GetFileTypeSpec
|
||||
HPath.IO.MoveFileSpec
|
||||
HPath.IO.MoveFileOverwriteSpec
|
||||
HPath.IO.RecreateSymlinkSpec
|
||||
HPath.IO.RenameFileSpec
|
||||
Utils
|
||||
GHC-Options: -Wall
|
||||
Build-Depends: base
|
||||
, HUnit
|
||||
, bytestring
|
||||
, hpath
|
||||
, hspec >= 1.3
|
||||
, process
|
||||
, unix
|
||||
, utf8-string
|
||||
|
||||
benchmark bench.hs
|
||||
default-language: Haskell2010
|
||||
type: exitcode-stdio-1.0
|
||||
hs-source-dirs: benchmarks
|
||||
main-is: Bench.hs
|
||||
|
||||
build-depends:
|
||||
base,
|
||||
hpath,
|
||||
bytestring,
|
||||
unix,
|
||||
directory >= 1.1 && < 1.3,
|
||||
filepath >= 1.2 && < 1.5,
|
||||
process >= 1.0 && < 1.3,
|
||||
criterion >= 0.6 && < 1.2
|
||||
ghc-options: -O2
|
||||
|
||||
source-repository head
|
||||
type: git
|
||||
location: https://github.com/hasufell/hpath
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
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:
|
||||
* fix tests, so they work with the sdist tarball too
|
||||
* added the following function to HPath.IO: createSymlink
|
||||
0.7.1:
|
||||
* various cleanups and documentation improvements
|
||||
* added the following functions to System.Posix.FilePath: splitSearchPath, getSearchPath, stripExtension, makeRelative, makeValid
|
||||
0.7.0:
|
||||
* use 'sendfile' from 'simple-sendfile' in _copyFile and do read/write as a fallback only
|
||||
* add isFileName, hasParentDir, hiddenFile to System.Posix.FilePath
|
||||
* add our own openFd version for more control
|
||||
* small documentation improvements
|
||||
* add a getDirectoryContents' version that works on Fd
|
||||
* lift version constraints in benchmark
|
||||
* remove fpToString and userStringToFP, use Data.ByteString.UTF8 directly instead
|
||||
0.6.0:
|
||||
* fixes 'throwDestinationInSource' to be more reliable.
|
||||
* removes some unused HPathIOException constructors
|
||||
* consistently provide exception constructor identifiers
|
||||
* be less harsh when non-supported file types get passed to our functions, possibly ignoring them
|
||||
* minor cleanups
|
||||
0.5.9:
|
||||
* Adds our posix-paths fork and a lot of IO operations.
|
||||
0.5.8:
|
||||
* First version of the fork.
|
||||
0.5.7:
|
||||
* Fix haddock problem.
|
||||
0.5.6:
|
||||
* Reject only .. and .
|
||||
0.5.5:
|
||||
* Use filepath's isValid function for additional sanity checks
|
||||
0.5.4:
|
||||
* Disable parsing of path consisting only of "."
|
||||
* Add NFData instance for Path
|
||||
* Some typo/docs improvements
|
||||
* Add standard headers to modules
|
||||
0.5.3:
|
||||
* Added conversion functions.
|
||||
|
||||
0.2.0:
|
||||
|
||||
* Rename parentAbs to simply parent.
|
||||
* Add dirname.
|
||||
|
||||
0.3.0:
|
||||
* Removed Generic instance.
|
||||
|
||||
0.4.0:
|
||||
* Implemented stricter parsing, disabling use of "..".
|
||||
* Made stripDir generic over MonadThrow
|
||||
|
||||
0.5.0:
|
||||
* Fix stripDir p p /= Nothing bug.
|
||||
|
||||
0.5.2:
|
||||
* Removed unused DeriveGeneric.
|
|
@ -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.
|
|
@ -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`
|
|
@ -0,0 +1,2 @@
|
|||
import Distribution.Simple
|
||||
main = defaultMain
|
|
@ -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
|
||||
|
|
@ -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
|
|
@ -13,7 +13,11 @@
|
|||
{-# LANGUAGE CPP #-}
|
||||
{-# LANGUAGE DeriveDataTypeable #-}
|
||||
{-# LANGUAGE EmptyDataDecls #-}
|
||||
#if __GLASGOW_HASKELL__ >= 708
|
||||
{-# LANGUAGE PatternSynonyms #-}
|
||||
#endif
|
||||
{-# LANGUAGE QuasiQuotes #-}
|
||||
{-# LANGUAGE TemplateHaskell #-}
|
||||
|
||||
module HPath
|
||||
(
|
||||
|
@ -21,30 +25,39 @@ module HPath
|
|||
Abs
|
||||
,Path
|
||||
,Rel
|
||||
,Fn
|
||||
,PathParseException
|
||||
,PathException
|
||||
#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
|
||||
|
||||
|
@ -54,13 +67,18 @@ import Control.Monad.Catch (MonadThrow(..))
|
|||
import Data.ByteString(ByteString, stripPrefix)
|
||||
#else
|
||||
import Data.ByteString(ByteString)
|
||||
import qualified Data.List as L
|
||||
#endif
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8
|
||||
import Data.Data
|
||||
import qualified Data.List as L
|
||||
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 ((</>))
|
||||
|
||||
|
||||
|
@ -73,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
|
||||
|
@ -89,13 +103,16 @@ data PathException = RootDirHasNoBasename
|
|||
deriving (Show,Typeable)
|
||||
instance Exception PathException
|
||||
|
||||
instance RelC Rel
|
||||
instance RelC Fn
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- PatternSynonyms
|
||||
|
||||
#if __GLASGOW_HASKELL__ >= 710
|
||||
pattern Path :: ByteString -> Path a
|
||||
#endif
|
||||
#if __GLASGOW_HASKELL__ >= 708
|
||||
pattern Path x <- (MkPath x)
|
||||
#endif
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
-- Path Parsers
|
||||
|
@ -113,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)
|
||||
|
@ -126,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)
|
||||
|
||||
|
||||
|
@ -141,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)
|
||||
|
@ -164,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
|
||||
|
@ -217,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
|
||||
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
@ -240,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.
|
||||
|
@ -275,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.
|
||||
--
|
||||
|
@ -292,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)
|
||||
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
@ -352,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
|
||||
|
@ -364,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
|
||||
|
|
@ -3,27 +3,30 @@
|
|||
-- | Internal types and functions.
|
||||
|
||||
module HPath.Internal
|
||||
(Path(..)
|
||||
,RelC)
|
||||
(Path(..))
|
||||
where
|
||||
|
||||
import Control.DeepSeq (NFData (..))
|
||||
import Data.ByteString (ByteString)
|
||||
import Data.Data
|
||||
|
||||
-- | Path of some base and type.
|
||||
-- | The main Path type.
|
||||
--
|
||||
-- Internally is a string. The string 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)
|
||||
|
||||
-- | String equality.
|
||||
-- | ByteString equality.
|
||||
--
|
||||
-- The following property holds:
|
||||
--
|
||||
|
@ -31,7 +34,7 @@ data Path b = MkPath ByteString
|
|||
instance Eq (Path b) where
|
||||
(==) (MkPath x) (MkPath y) = x == y
|
||||
|
||||
-- | String ordering.
|
||||
-- | ByteString ordering.
|
||||
--
|
||||
-- The following property holds:
|
||||
--
|
||||
|
@ -39,7 +42,7 @@ instance Eq (Path b) where
|
|||
instance Ord (Path b) where
|
||||
compare (MkPath x) (MkPath y) = compare x y
|
||||
|
||||
-- | Same as 'Path.toFilePath'.
|
||||
-- | Same as 'HPath.toFilePath'.
|
||||
--
|
||||
-- The following property holds:
|
||||
--
|
||||
|
@ -50,6 +53,3 @@ instance Show (Path b) where
|
|||
instance NFData (Path b) where
|
||||
rnf (MkPath x) = rnf x
|
||||
|
||||
|
||||
class RelC m
|
||||
|
838
src/HPath/IO.hs
838
src/HPath/IO.hs
|
@ -1,838 +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 not explicitly supported right now. Calling any of these
|
||||
-- functions on such a file may throw an exception or just do
|
||||
-- nothing.
|
||||
|
||||
{-# 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
|
||||
-- * 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
|
||||
)
|
||||
import Network.Sendfile
|
||||
(
|
||||
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.
|
||||
--
|
||||
-- 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'
|
||||
|
||||
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.
|
||||
--
|
||||
-- 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
|
||||
|
||||
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 symlink file is wrong type (file)
|
||||
-- - `InvalidArgument` if symlink file is wrong type (directory)
|
||||
-- - `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.
|
||||
--
|
||||
-- Throws:
|
||||
--
|
||||
-- - `NoSuchThing` if source file does not exist
|
||||
-- - `PermissionDenied` if output directory is not writable
|
||||
-- - `PermissionDenied` if source directory can't be opened
|
||||
-- - `InvalidArgument` if source file is wrong type (symlink)
|
||||
-- - `InvalidArgument` if source file is wrong type (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.
|
||||
-- This also works if source and destination are the same file.
|
||||
--
|
||||
-- Safety/reliability concerns:
|
||||
--
|
||||
-- * not atomic, since it uses read/write
|
||||
--
|
||||
-- Throws:
|
||||
--
|
||||
-- - `NoSuchThing` if source file does not exist
|
||||
-- - `PermissionDenied` if output directory is not writable
|
||||
-- - `PermissionDenied` if source directory can't be opened
|
||||
-- - `InvalidArgument` if source file is wrong type (symlink)
|
||||
-- - `InvalidArgument` if source file is wrong type (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 anything. In case of a symlink,
|
||||
-- it is just recreated, even if it points to a directory.
|
||||
--
|
||||
-- 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.
|
||||
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.
|
||||
--
|
||||
-- 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, whatever it may be.
|
||||
-- In case of directory, performs recursive deletion. In case of
|
||||
-- a symlink, the symlink file is deleted.
|
||||
--
|
||||
-- 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
|
||||
|
||||
|
||||
|
||||
|
||||
----------------------------
|
||||
--[ 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
|
||||
--
|
||||
-- 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.
|
||||
--
|
||||
-- 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
|
|
@ -1,7 +0,0 @@
|
|||
module HPath.IO where
|
||||
|
||||
|
||||
import HPath
|
||||
|
||||
canonicalizePath :: Path Abs -> IO (Path Abs)
|
||||
|
|
@ -1,358 +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
|
||||
|
||||
|
||||
-- |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
|
|
@ -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)
|
|
@ -1,66 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CanonicalizePathSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/canonicalizePathSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.canonicalizePath" $ do
|
||||
|
||||
-- successes --
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withPwd (specDir `ba` "file") return
|
||||
canonicalizePath' (specDir `ba` "file")
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withPwd (specDir `ba` "dir") return
|
||||
canonicalizePath' (specDir `ba` "dir")
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withPwd (specDir `ba` "file") return
|
||||
canonicalizePath' (specDir `ba` "fileSym")
|
||||
`shouldReturn` path
|
||||
|
||||
it "canonicalizePath, all fine" $ do
|
||||
path <- withPwd (specDir `ba` "dir") return
|
||||
canonicalizePath' (specDir `ba` "dirSym")
|
||||
`shouldReturn` path
|
||||
|
||||
|
||||
-- posix failures --
|
||||
it "canonicalizePath, broken symlink" $
|
||||
canonicalizePath' (specDir `ba` "brokenSym")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "canonicalizePath, file does not exist" $
|
||||
canonicalizePath' (specDir `ba` "nothingBlah")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
|
@ -1,110 +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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/copyDirRecursiveOverwriteSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.copyDirRecursiveOverwrite" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyDirRecursiveOverwrite, all fine" $ do
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "outputDir")
|
||||
removeDirIfExists $ specDir `ba` "outputDir"
|
||||
|
||||
it "copyDirRecursiveOverwrite, all fine and compare" $ do
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "outputDir")
|
||||
(system $ "diff -r --no-dereference "
|
||||
++ specDir' ++ "inputDir" ++ " "
|
||||
++ specDir' ++ "outputDir")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeDirIfExists $ specDir `ba` "outputDir"
|
||||
|
||||
it "copyDirRecursiveOverwrite, destination dir already exists" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
|
||||
-- posix failures --
|
||||
it "copyDirRecursiveOverwrite, source directory does not exist" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "doesNotExist")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyDirRecursiveOverwrite, no write permission on output dir" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "noWritePerm/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursiveOverwrite, cannot open output dir" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursiveOverwrite, cannot open source dir" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "noPerms/inputDir")
|
||||
(specDir `ba` "foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursiveOverwrite, destination already exists and is a file" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyDirRecursiveOverwrite, wrong input (regular file)" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "wrongInput")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyDirRecursiveOverwrite, wrong input (symlink to directory)" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "wrongInputSymL")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
-- custom failures
|
||||
it "copyDirRecursiveOverwrite, destination in source" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "inputDir/foo")
|
||||
`shouldThrow`
|
||||
isDestinationInSource
|
||||
|
||||
it "copyDirRecursiveOverwrite, destination and source same directory" $
|
||||
copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "inputDir")
|
||||
`shouldThrow`
|
||||
isSameFile
|
|
@ -1,112 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CopyDirRecursiveSpec 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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/copyDirRecursiveSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.copyDirRecursive" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyDirRecursive, all fine" $ do
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "outputDir")
|
||||
removeDirIfExists (specDir `ba` "outputDir")
|
||||
|
||||
it "copyDirRecursive, all fine and compare" $ do
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "outputDir")
|
||||
(system $ "diff -r --no-dereference "
|
||||
++ specDir' ++ "inputDir" ++ " "
|
||||
++ specDir' ++ "outputDir")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeDirIfExists (specDir `ba` "outputDir")
|
||||
|
||||
-- posix failures --
|
||||
it "copyDirRecursive, source directory does not exist" $
|
||||
copyDirRecursive' (specDir `ba` "doesNotExist")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyDirRecursive, no write permission on output dir" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "noWritePerm/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive, cannot open output dir" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive, cannot open source dir" $
|
||||
copyDirRecursive' (specDir `ba` "noPerms/inputDir")
|
||||
(specDir `ba` "foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyDirRecursive, destination dir already exists" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyDirRecursive, destination already exists and is a file" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyDirRecursive, wrong input (regular file)" $
|
||||
copyDirRecursive' (specDir `ba` "wrongInput")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyDirRecursive, wrong input (symlink to directory)" $
|
||||
copyDirRecursive' (specDir `ba` "wrongInputSymL")
|
||||
(specDir `ba` "outputDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
-- custom failures
|
||||
it "copyDirRecursive, destination in source" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "inputDir/foo")
|
||||
`shouldThrow`
|
||||
isDestinationInSource
|
||||
|
||||
it "copyDirRecursive, destination and source same directory" $
|
||||
copyDirRecursive' (specDir `ba` "inputDir")
|
||||
(specDir `ba` "inputDir")
|
||||
`shouldThrow`
|
||||
isSameFile
|
|
@ -1,109 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CopyFileOverwriteSpec 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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/copyFileOverwriteSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.copyFileOverwrite" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyFileOverwrite, everything clear" $ do
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
removeFileIfExists (specDir `ba` "outputFile")
|
||||
|
||||
it "copyFileOverwrite, output file already exists, all clear" $ do
|
||||
copyFile' (specDir `ba` "alreadyExists") (specDir `ba` "alreadyExists.bak")
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "alreadyExists")
|
||||
(system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
|
||||
++ specDir' ++ "alreadyExists")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists (specDir `ba` "alreadyExists")
|
||||
copyFile' (specDir `ba` "alreadyExists.bak") (specDir `ba` "alreadyExists")
|
||||
removeFileIfExists (specDir `ba` "alreadyExists.bak")
|
||||
|
||||
it "copyFileOverwrite, and compare" $ do
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
(system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
|
||||
++ specDir' ++ "outputFile")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists (specDir `ba` "outputFile")
|
||||
|
||||
-- posix failures --
|
||||
it "copyFileOverwrite, input file does not exist" $
|
||||
copyFileOverwrite' (specDir `ba` "noSuchFile")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyFileOverwrite, no permission to write to output directory" $
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputDirNoWrite/outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFileOverwrite, cannot open output directory" $
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "noPerms/outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFileOverwrite, cannot open source directory" $
|
||||
copyFileOverwrite' (specDir `ba` "noPerms/inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFileOverwrite, wrong input type (symlink)" $
|
||||
copyFileOverwrite' (specDir `ba` "inputFileSymL")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "copyFileOverwrite, wrong input type (directory)" $
|
||||
copyFileOverwrite' (specDir `ba` "wrongInput")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyFileOverwrite, output file already exists and is a dir" $
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
-- custom failures --
|
||||
it "copyFileOverwrite, output and input are same file" $
|
||||
copyFileOverwrite' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "inputFile")
|
||||
`shouldThrow` isSameFile
|
|
@ -1,105 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CopyFileSpec 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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/copyFileSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.copyFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "copyFile, everything clear" $ do
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
removeFileIfExists (specDir `ba` "outputFile")
|
||||
|
||||
it "copyFile, and compare" $ do
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
(system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
|
||||
++ specDir' ++ "outputFile")
|
||||
`shouldReturn` ExitSuccess
|
||||
removeFileIfExists (specDir `ba` "outputFile")
|
||||
|
||||
-- posix failures --
|
||||
it "copyFile, input file does not exist" $
|
||||
copyFile' (specDir `ba` "noSuchFile")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "copyFile, no permission to write to output directory" $
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "outputDirNoWrite/outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile, cannot open output directory" $
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "noPerms/outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile, cannot open source directory" $
|
||||
copyFile' (specDir `ba` "noPerms/inputFile")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "copyFile, wrong input type (symlink)" $
|
||||
copyFile' (specDir `ba` "inputFileSymL")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "copyFile, wrong input type (directory)" $
|
||||
copyFile' (specDir `ba` "wrongInput")
|
||||
(specDir `ba` "outputFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "copyFile, output file already exists" $
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "copyFile, output file already exists and is a dir" $
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
-- custom failures --
|
||||
it "copyFile, output and input are same file" $
|
||||
copyFile' (specDir `ba` "inputFile")
|
||||
(specDir `ba` "inputFile")
|
||||
`shouldThrow`
|
||||
isSameFile
|
|
@ -1,54 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CreateDirSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/createDirSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.createDir" $ do
|
||||
|
||||
-- successes --
|
||||
it "createDir, all fine" $ do
|
||||
createDir' (specDir `ba` "newDir")
|
||||
removeDirIfExists (specDir `ba` "newDir")
|
||||
|
||||
-- posix failures --
|
||||
it "createDir, can't write to output directory" $
|
||||
createDir' (specDir `ba` "noWritePerms/newDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createDir, can't open output directory" $
|
||||
createDir' (specDir `ba` "noPerms/newDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createDir, destination directory already exists" $
|
||||
createDir' (specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.CreateRegularFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/createRegularFileSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.createRegularFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "createRegularFile, all fine" $ do
|
||||
createRegularFile' (specDir `ba` "newDir")
|
||||
removeFileIfExists (specDir `ba` "newDir")
|
||||
|
||||
-- posix failures --
|
||||
it "createRegularFile, can't write to destination directory" $
|
||||
createRegularFile' (specDir `ba` "noWritePerms/newDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createRegularFile, can't write to destination directory" $
|
||||
createRegularFile' (specDir `ba` "noPerms/newDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "createRegularFile, destination file already exists" $
|
||||
createRegularFile' (specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.DeleteDirRecursiveSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/deleteDirRecursiveSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.deleteDirRecursive" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteDirRecursive, empty directory, all fine" $ do
|
||||
createDir' (specDir `ba` "testDir")
|
||||
deleteDirRecursive' (specDir `ba` "testDir")
|
||||
getSymbolicLinkStatus (specDir `ba` "testDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDirRecursive, empty directory with null permissions, all fine" $ do
|
||||
createDir' (specDir `ba` "noPerms/testDir")
|
||||
noPerms (specDir `ba` "noPerms/testDir")
|
||||
deleteDirRecursive' (specDir `ba` "noPerms/testDir")
|
||||
|
||||
it "deleteDirRecursive, non-empty directory, all fine" $ do
|
||||
createDir' (specDir `ba` "nonEmpty")
|
||||
createDir' (specDir `ba` "nonEmpty/dir1")
|
||||
createDir' (specDir `ba` "nonEmpty/dir2")
|
||||
createDir' (specDir `ba` "nonEmpty/dir2/dir3")
|
||||
createRegularFile' (specDir `ba` "nonEmpty/file1")
|
||||
createRegularFile' (specDir `ba` "nonEmpty/dir1/file2")
|
||||
deleteDirRecursive' (specDir `ba` "nonEmpty")
|
||||
getSymbolicLinkStatus (specDir `ba` "nonEmpty")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteDirRecursive, can't open parent directory" $ do
|
||||
createDir' (specDir `ba` "noPerms/foo")
|
||||
noPerms (specDir `ba` "noPerms")
|
||||
(deleteDirRecursive' (specDir `ba` "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied))
|
||||
>> normalDirPerms (specDir `ba` "noPerms")
|
||||
>> deleteDir' (specDir `ba` "noPerms/foo")
|
||||
|
||||
it "deleteDirRecursive, can't write to parent directory" $ do
|
||||
createDir' (specDir `ba` "noWritable/foo")
|
||||
noWritableDirPerms (specDir `ba` "noWritable")
|
||||
(deleteDirRecursive' (specDir `ba` "noWritable/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied))
|
||||
normalDirPerms (specDir `ba` "noWritable")
|
||||
deleteDir' (specDir `ba` "noWritable/foo")
|
||||
|
||||
it "deleteDirRecursive, wrong file type (symlink to directory)" $
|
||||
deleteDirRecursive' (specDir `ba` "dirSym")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDirRecursive, wrong file type (regular file)" $
|
||||
deleteDirRecursive' (specDir `ba` "file")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDirRecursive, directory does not exist" $
|
||||
deleteDirRecursive' (specDir `ba` "doesNotExist")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.DeleteDirSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/deleteDirSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.deleteDir" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteDir, empty directory, all fine" $ do
|
||||
createDir' (specDir `ba` "testDir")
|
||||
deleteDir' (specDir `ba` "testDir")
|
||||
getSymbolicLinkStatus (specDir `ba` "testDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDir, directory with null permissions, all fine" $ do
|
||||
createDir' (specDir `ba` "noPerms/testDir")
|
||||
noPerms (specDir `ba` "noPerms/testDir")
|
||||
deleteDir' (specDir `ba` "noPerms/testDir")
|
||||
getSymbolicLinkStatus (specDir `ba` "testDir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteDir, wrong file type (symlink to directory)" $
|
||||
deleteDir' (specDir `ba` "dirSym")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDir, wrong file type (regular file)" $
|
||||
deleteDir' (specDir `ba` "file")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteDir, directory does not exist" $
|
||||
deleteDir' (specDir `ba` "doesNotExist")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteDir, directory not empty" $
|
||||
deleteDir' (specDir `ba` "dir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == UnsatisfiedConstraints)
|
||||
|
||||
it "deleteDir, can't open parent directory" $ do
|
||||
createDir' (specDir `ba` "noPerms/foo")
|
||||
noPerms (specDir `ba` "noPerms")
|
||||
(deleteDir' (specDir `ba` "noPerms/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied))
|
||||
>> normalDirPerms (specDir `ba` "noPerms")
|
||||
>> deleteDir' (specDir `ba` "noPerms/foo")
|
||||
|
||||
it "deleteDir, can't write to parent directory, still fine" $ do
|
||||
createDir' (specDir `ba` "noWritable/foo")
|
||||
noWritableDirPerms (specDir `ba` "noWritable")
|
||||
(deleteDir' (specDir `ba` "noWritable/foo")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied))
|
||||
normalDirPerms (specDir `ba` "noWritable")
|
||||
deleteDir' (specDir `ba` "noWritable/foo")
|
||||
|
||||
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.DeleteFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import System.Posix.Files.ByteString
|
||||
(
|
||||
getSymbolicLinkStatus
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/deleteFileSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.deleteFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "deleteFile, regular file, all fine" $ do
|
||||
createRegularFile' (specDir `ba` "testFile")
|
||||
deleteFile' (specDir `ba` "testFile")
|
||||
getSymbolicLinkStatus (specDir `ba` "testFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteFile, symlink, all fine" $ do
|
||||
recreateSymlink' (specDir `ba` "syml")
|
||||
(specDir `ba` "testFile")
|
||||
deleteFile' (specDir `ba` "testFile")
|
||||
getSymbolicLinkStatus (specDir `ba` "testFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
-- posix failures --
|
||||
it "deleteFile, wrong file type (directory)" $
|
||||
deleteFile' (specDir `ba` "dir")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "deleteFile, file does not exist" $
|
||||
deleteFile' (specDir `ba` "doesNotExist")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "deleteFile, can't read directory" $
|
||||
deleteFile' (specDir `ba` "noPerms/blah")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.GetDirsFilesSpec where
|
||||
|
||||
|
||||
import Control.Applicative
|
||||
(
|
||||
(<$>)
|
||||
)
|
||||
import Data.List
|
||||
(
|
||||
sort
|
||||
)
|
||||
import Data.Maybe
|
||||
(
|
||||
fromJust
|
||||
)
|
||||
import qualified HPath as P
|
||||
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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/getDirsFilesSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.getDirsFiles" $ do
|
||||
|
||||
-- successes --
|
||||
it "getDirsFiles, all fine" $ do
|
||||
pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
|
||||
expectedFiles <- mapM P.parseRel [(specDir `ba ` ".hidden")
|
||||
,(specDir `ba ` "Lala")
|
||||
,(specDir `ba ` "dir")
|
||||
,(specDir `ba ` "dirsym")
|
||||
,(specDir `ba ` "file")
|
||||
,(specDir `ba ` "noPerms")
|
||||
,(specDir `ba ` "syml")]
|
||||
(fmap sort $ getDirsFiles' specDir)
|
||||
`shouldReturn` fmap (pwd P.</>) expectedFiles
|
||||
|
||||
-- posix failures --
|
||||
it "getDirsFiles, nonexistent directory" $
|
||||
getDirsFiles' (specDir `ba ` "nothingHere")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "getDirsFiles, wrong file type (file)" $
|
||||
getDirsFiles' (specDir `ba ` "file")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InappropriateType)
|
||||
|
||||
it "getDirsFiles, wrong file type (symlink to file)" $
|
||||
getDirsFiles' (specDir `ba ` "syml")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "getDirsFiles, wrong file type (symlink to dir)" $
|
||||
getDirsFiles' (specDir `ba ` "dirsym")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "getDirsFiles, can't open directory" $
|
||||
getDirsFiles' (specDir `ba ` "noPerms")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.GetFileTypeSpec where
|
||||
|
||||
|
||||
import HPath.IO
|
||||
import Test.Hspec
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/getFileTypeSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.getFileType" $ do
|
||||
|
||||
-- successes --
|
||||
it "getFileType, regular file" $
|
||||
getFileType' (specDir `ba` "regularfile")
|
||||
`shouldReturn` RegularFile
|
||||
|
||||
it "getFileType, directory" $
|
||||
getFileType' (specDir `ba` "directory")
|
||||
`shouldReturn` Directory
|
||||
|
||||
it "getFileType, directory with null permissions" $
|
||||
getFileType' (specDir `ba` "noPerms")
|
||||
`shouldReturn` Directory
|
||||
|
||||
it "getFileType, symlink to file" $
|
||||
getFileType' (specDir `ba` "symlink")
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
it "getFileType, symlink to directory" $
|
||||
getFileType' (specDir `ba` "symlinkD")
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
it "getFileType, broken symlink" $
|
||||
getFileType' (specDir `ba` "brokenSymlink")
|
||||
`shouldReturn` SymbolicLink
|
||||
|
||||
-- posix failures --
|
||||
it "getFileType, file does not exist" $
|
||||
getFileType' (specDir `ba` "nothingHere")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "getFileType, can't open directory" $
|
||||
getFileType' (specDir `ba` "noPerms/forz")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
|
@ -1,93 +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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/moveFileOverwriteSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.moveFileOverwrite" $ do
|
||||
|
||||
-- successes --
|
||||
it "moveFileOverwrite, all fine" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
it "moveFileOverwrite, all fine" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "dir/movedFile")
|
||||
|
||||
it "moveFileOverwrite, all fine on symlink" $
|
||||
moveFileOverwrite' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
it "moveFileOverwrite, all fine on directory" $
|
||||
moveFileOverwrite' (specDir `ba` "dir")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
it "moveFileOverwrite, destination file already exists" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExists")
|
||||
|
||||
-- posix failures --
|
||||
it "moveFileOverwrite, source file does not exist" $
|
||||
moveFileOverwrite' (specDir `ba` "fileDoesNotExist")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "moveFileOverwrite, can't write to destination directory" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noWritePerm/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFileOverwrite, can't open destination directory" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noPerms/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFileOverwrite, can't open source directory" $
|
||||
moveFileOverwrite' (specDir `ba` "noPerms/myFile")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
-- custom failures --
|
||||
it "moveFileOverwrite, move from file to dir" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
isDirDoesExist
|
||||
|
||||
it "moveFileOverwrite, source and dest are same file" $
|
||||
moveFileOverwrite' (specDir `ba` "myFile")
|
||||
(specDir `ba` "myFile")
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.MoveFileSpec 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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/moveFileSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.moveFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "moveFile, all fine" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
it "moveFile, all fine" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "dir/movedFile")
|
||||
|
||||
it "moveFile, all fine on symlink" $
|
||||
moveFile' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
it "moveFile, all fine on directory" $
|
||||
moveFile' (specDir `ba` "dir")
|
||||
(specDir `ba` "movedFile")
|
||||
|
||||
-- posix failures --
|
||||
it "moveFile, source file does not exist" $
|
||||
moveFile' (specDir `ba` "fileDoesNotExist")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "moveFile, can't write to destination directory" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noWritePerm/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFile, can't open destination directory" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noPerms/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "moveFile, can't open source directory" $
|
||||
moveFile' (specDir `ba` "noPerms/myFile")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
-- custom failures --
|
||||
it "moveFile, destination file already exists" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
isFileDoesExist
|
||||
|
||||
it "moveFile, move from file to dir" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
isDirDoesExist
|
||||
|
||||
it "moveFile, source and dest are same file" $
|
||||
moveFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "myFile")
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.RecreateSymlinkSpec 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)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/recreateSymlinkSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.recreateSymlink" $ do
|
||||
|
||||
-- successes --
|
||||
it "recreateSymLink, all fine" $ do
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "movedFile")
|
||||
removeFileIfExists (specDir `ba` "movedFile")
|
||||
|
||||
it "recreateSymLink, all fine" $ do
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "dir/movedFile")
|
||||
removeFileIfExists (specDir `ba` "dir/movedFile")
|
||||
|
||||
-- posix failures --
|
||||
it "recreateSymLink, wrong input type (file)" $
|
||||
recreateSymlink' (specDir `ba` "myFile")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "recreateSymLink, wrong input type (directory)" $
|
||||
recreateSymlink' (specDir `ba` "dir")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == InvalidArgument)
|
||||
|
||||
it "recreateSymLink, can't write to destination directory" $
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "noWritePerm/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink, can't open destination directory" $
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "noPerms/movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink, can't open source directory" $
|
||||
recreateSymlink' (specDir `ba` "noPerms/myFileL")
|
||||
(specDir `ba` "movedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "recreateSymLink, destination file already exists" $
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
it "recreateSymLink, destination already exists and is a dir" $
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == AlreadyExists)
|
||||
|
||||
-- custom failures --
|
||||
it "recreateSymLink, source and destination are the same file" $
|
||||
recreateSymlink' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "myFileL")
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
{-# LANGUAGE OverloadedStrings #-}
|
||||
|
||||
module HPath.IO.RenameFileSpec where
|
||||
|
||||
|
||||
import Test.Hspec
|
||||
import HPath.IO.Errors
|
||||
import System.IO.Error
|
||||
(
|
||||
ioeGetErrorType
|
||||
)
|
||||
import GHC.IO.Exception
|
||||
(
|
||||
IOErrorType(..)
|
||||
)
|
||||
import Utils
|
||||
import qualified Data.ByteString as BS
|
||||
import Data.ByteString.UTF8 (toString)
|
||||
|
||||
|
||||
ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
|
||||
ba = BS.append
|
||||
|
||||
specDir :: BS.ByteString
|
||||
specDir = "test/HPath/IO/renameFileSpec/"
|
||||
|
||||
specDir' :: String
|
||||
specDir' = toString specDir
|
||||
|
||||
|
||||
spec :: Spec
|
||||
spec =
|
||||
describe "HPath.IO.renameFile" $ do
|
||||
|
||||
-- successes --
|
||||
it "renameFile, all fine" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "renamedFile")
|
||||
|
||||
it "renameFile, all fine" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "dir/renamedFile")
|
||||
|
||||
it "renameFile, all fine on symlink" $
|
||||
renameFile' (specDir `ba` "myFileL")
|
||||
(specDir `ba` "renamedFile")
|
||||
|
||||
it "renameFile, all fine on directory" $
|
||||
renameFile' (specDir `ba` "dir")
|
||||
(specDir `ba` "renamedFile")
|
||||
|
||||
-- posix failures --
|
||||
it "renameFile, source file does not exist" $
|
||||
renameFile' (specDir `ba` "fileDoesNotExist")
|
||||
(specDir `ba` "renamedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == NoSuchThing)
|
||||
|
||||
it "renameFile, can't write to output directory" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noWritePerm/renamedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "renameFile, can't open output directory" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "noPerms/renamedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
it "renameFile, can't open source directory" $
|
||||
renameFile' (specDir `ba` "noPerms/myFile")
|
||||
(specDir `ba` "renamedFile")
|
||||
`shouldThrow`
|
||||
(\e -> ioeGetErrorType e == PermissionDenied)
|
||||
|
||||
-- custom failures --
|
||||
it "renameFile, destination file already exists" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExists")
|
||||
`shouldThrow`
|
||||
isFileDoesExist
|
||||
|
||||
it "renameFile, move from file to dir" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "alreadyExistsD")
|
||||
`shouldThrow`
|
||||
isDirDoesExist
|
||||
|
||||
it "renameFile, source and dest are same file" $
|
||||
renameFile' (specDir `ba` "myFile")
|
||||
(specDir `ba` "myFile")
|
||||
`shouldThrow`
|
||||
isSameFile
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue