Cleaning up Node.FS.Perms a bit more

* More instances: Eq, Ord
* Better Show instances
* Ensure permsFromString (permsToString x) == Just x

Author: hdgarrood

README.md

@@ -190,18 +190,36 @@ newtype Perm
 A `Perm` value specifies what is allowed to be done with a particular
 file by a particular class of user — that is, whether it is
 readable, writable, and/or executable. It has a semigroup instance, which
-allows you to combine permissions; for example, `r <> w` means "readable
-and writable".
+allows you to combine permissions; for example, `read <> write` means
+"readable and writable".
 
-#### `Perms`
+#### `eqPerm`
 
 ``` purescript
-newtype Perms
+instance eqPerm :: Eq Perm
+```
+
+
+#### `ordPerm`
+
+``` purescript
+instance ordPerm :: Ord Perm
+```
+
+
+#### `showPerm`
+
+``` purescript
+instance showPerm :: Show Perm
+```
+
+
+#### `semigroupPerm`
+
+``` purescript
+instance semigroupPerm :: Semigroup Perm
 ```
 
-A `Perms` value includes all the permissions information about a
-particular file or directory, by storing a `Perm` value for each of the
-file owner, the group, and others.
 
 #### `none`
 
@@ -212,26 +230,26 @@ none :: Perm
 No permissions. This is the identity of the `Semigroup` operation `(<>)`
 for `Perm`.
 
-#### `r`
+#### `read`
 
 ``` purescript
-r :: Perm
+read :: Perm
 ```
 
 The "readable" permission.
 
-#### `w`
+#### `write`
 
 ``` purescript
-w :: Perm
+write :: Perm
 ```
 
 The "writable" permission.
 
-#### `x`
+#### `execute`
 
 ``` purescript
-x :: Perm
+execute :: Perm
 ```
 
 The "executable" permission.
@@ -244,10 +262,34 @@ all :: Perm
 
 All permissions: readable, writable, and executable.
 
-#### `semigroupPerm`
+#### `Perms`
 
 ``` purescript
-instance semigroupPerm :: Semigroup Perm
+newtype Perms
+```
+
+A `Perms` value includes all the permissions information about a
+particular file or directory, by storing a `Perm` value for each of the
+file owner, the group, and any other users.
+
+#### `eqPerms`
+
+``` purescript
+instance eqPerms :: Eq Perms
+```
+
+
+#### `ordPerms`
+
+``` purescript
+instance ordPerms :: Ord Perms
+```
+
+
+#### `showPerms`
+
+``` purescript
+instance showPerms :: Show Perms
 ```
 
 
@@ -259,16 +301,16 @@ permsFromString :: String -> Maybe Perms
 
 Attempt to parse a `Perms` value from a `String` containing an octal
 integer. For example,
-`permsFromString "644" == Just (mkPerms (r <> w) r r)`.
+`permsFromString "0644" == Just (mkPerms (read <> write) read read)`.
 
 #### `mkPerms`
 
 ``` purescript
 mkPerms :: Perm -> Perm -> Perm -> Perms
 ```
 
-Create a `Perms` value. The arguments represent the user's, group's, and
-others' permission sets, respectively.
+Create a `Perms` value. The arguments represent the owner's, group's, and
+other users' permission sets, respectively.
 
 #### `permsToString`
 
@@ -289,20 +331,6 @@ permsToInt :: Perms -> Int
 
 Convert a `Perms` value to an `Int`, via `permsToString`.
 
-#### `showPerm`
-
-``` purescript
-instance showPerm :: Show Perm
-```
-
-
-#### `showPerms`
-
-``` purescript
-instance showPerms :: Show Perms
-```
-
-
 
 ## Module Node.FS.Stats
 

src/Node/FS/Async.purs

@@ -227,7 +227,7 @@ mkdir :: forall eff. FilePath
                   -> Callback eff Unit
                   -> Eff (fs :: FS | eff) Unit
 
-mkdir = flip mkdir' $ mkPerms (r <> w <> x) (r <> w <> x) (r <> w <> x)
+mkdir = flip mkdir' $ mkPerms all all all
 
 -- |
 -- Makes a new directory with the specified permissions.

src/Node/FS/Perms.purs

@@ -1,66 +1,113 @@
 module Node.FS.Perms
-  ( permsFromString
-  , permsToString
-  , permsToInt
+  ( Perm()
   , none
-  , r
-  , w
-  , x
+  , read
+  , write
+  , execute
   , all
-  , mkPerms
   , Perms()
-  , Perm()
+  , mkPerms
+  , permsFromString
+  , permsToString
+  , permsToInt
   ) where
 
 import Global (readInt)
+import Data.Array () -- for Semigroup and Functor instances
 import Data.Maybe (Maybe(..))
-import Data.Char (Char(), charString)
-import Data.String (toCharArray)
+import Data.Char (Char(), charString, fromCharCode)
+import Data.String (toCharArray, joinWith, drop, charAt)
 import Data.Int (Int(), fromNumber, toNumber)
 
 -- | A `Perm` value specifies what is allowed to be done with a particular
 -- | file by a particular class of user — that is, whether it is
 -- | readable, writable, and/or executable. It has a semigroup instance, which
--- | allows you to combine permissions; for example, `r <> w` means "readable
--- | and writable".
+-- | allows you to combine permissions; for example, `read <> write` means
+-- | "readable and writable".
 newtype Perm = Perm { r :: Boolean, w :: Boolean, x :: Boolean }
 
--- | A `Perms` value includes all the permissions information about a
--- | particular file or directory, by storing a `Perm` value for each of the
--- | file owner, the group, and others.
-newtype Perms = Perms { u :: Perm, g :: Perm, o :: Perm }
+instance eqPerm :: Eq Perm where
+  (==) (Perm { r = r1, w = w1, x = x1 }) (Perm { r = r2, w = w2, x = x2 }) =
+    r1 == r2  && w1 == w2 && x1 == x2
+  (/=) x y = not (x == y)
+
+instance ordPerm :: Ord Perm where
+  compare (Perm { r = r1, w = w1, x = x1 }) (Perm { r = r2, w = w2, x = x2 }) =
+    compare [r1, w1, x1] [r2, w2, x2]
+
+instance showPerm :: Show Perm where
+  show p | p == none = "none"
+  show p | p == all  = "all"
+  show (Perm { r = r, w = w, x = x }) =
+    joinWith " <> " ps
+    where
+    ps =
+      (if r then ["read"] else []) <>
+      (if w then ["write"] else []) <>
+      (if x then ["execute"] else [])
+
+instance semigroupPerm :: Semigroup Perm where
+  (<>) (Perm { r = r0, w = w0, x = x0 }) (Perm { r = r1, w = w1, x = x1 }) =
+    Perm { r: r0 || r1, w: w0 || w1, x: x0 || x1  }
+
+-- | Create a `Perm` value. The arguments represent the readable, writable, and
+-- | executable permissions, in that order.
+mkPerm :: Boolean -> Boolean -> Boolean -> Perm
+mkPerm r w x = Perm { r: r, w: w, x: x }
 
 -- | No permissions. This is the identity of the `Semigroup` operation `(<>)`
 -- | for `Perm`.
 none :: Perm
 none = Perm { r: false, w: false, x: false }
 
 -- | The "readable" permission.
-r :: Perm
-r = Perm { r: true, w: false, x: false }
+read :: Perm
+read = Perm { r: true, w: false, x: false }
 
 -- | The "writable" permission.
-w :: Perm
-w = Perm { r: false, w: true, x: false }
+write :: Perm
+write = Perm { r: false, w: true, x: false }
 
 -- | The "executable" permission.
-x :: Perm
-x = Perm { r: false, w: false, x: true }
+execute :: Perm
+execute = Perm { r: false, w: false, x: true }
 
 -- | All permissions: readable, writable, and executable.
 all :: Perm
-all = r <> w <> x
+all = read <> write <> execute
 
-instance semigroupPerm :: Semigroup Perm where
-  (<>) (Perm { r = r0, w = w0, x = x0 }) (Perm { r = r1, w = w1, x = x1 }) =
-    Perm { r: r0 || r1, w: w0 || w1, x: x0 || x1  }
+-- | A `Perms` value includes all the permissions information about a
+-- | particular file or directory, by storing a `Perm` value for each of the
+-- | file owner, the group, and any other users.
+newtype Perms = Perms { u :: Perm, g :: Perm, o :: Perm }
+
+instance eqPerms :: Eq Perms where
+  (==) (Perms { u = u1, g = g1, o = o1 }) (Perms { u = u2, g = g2, o = o2 }) =
+    u1 == u2  && g1 == g2 && o1 == o2
+  (/=) x y = not (x == y)
+
+instance ordPerms :: Ord Perms where
+  compare (Perms { u = u1, g = g1, o = o1 }) (Perms { u = u2, g = g2, o = o2 }) =
+    compare [u1, g1, o1] [u2, g2, o2]
+
+instance showPerms :: Show Perms where
+  show (Perms { u = u, g = g, o = o }) =
+    "mkPerms " <> joinWith " " (f <$> [u, g, o])
+    where
+    f perm = "(" <> show perm <> ")"
 
 -- | Attempt to parse a `Perms` value from a `String` containing an octal
 -- | integer. For example,
--- | `permsFromString "644" == Just (mkPerms (r <> w) r r)`.
+-- | `permsFromString "0644" == Just (mkPerms (read <> write) read read)`.
 permsFromString :: String -> Maybe Perms
-permsFromString = _perms <<< toCharArray
+permsFromString = _perms <<< toCharArray <<< dropPrefix zeroChar
   where
+    zeroChar = fromCharCode 48
+
+    dropPrefix x xs
+      | charAt 0 xs == Just x = drop 1 xs
+      | otherwise             = xs
+
     _perms [u, g, o] =
       mkPerms <$> permFromChar u
               <*> permFromChar g
@@ -71,22 +118,17 @@ permFromChar :: Char -> Maybe Perm
 permFromChar = _perm <<< charString
   where
     _perm "0" = Just $ none
-    _perm "1" = Just $ x
-    _perm "2" = Just $ w
-    _perm "3" = Just $ w <> x
-    _perm "4" = Just $ r
-    _perm "5" = Just $ r <> x
-    _perm "6" = Just $ r <> w
-    _perm "7" = Just $ r <> w <> x
+    _perm "1" = Just $ execute
+    _perm "2" = Just $ write
+    _perm "3" = Just $ write <> execute
+    _perm "4" = Just $ read
+    _perm "5" = Just $ read <> execute
+    _perm "6" = Just $ read <> write
+    _perm "7" = Just $ read <> write <> execute
     _perm _   = Nothing
 
--- | Create a `Perm` value. The arguments represent the readable, writable, and
--- | executable permissions, in that order.
-mkPerm :: Boolean -> Boolean -> Boolean -> Perm
-mkPerm r w x = Perm { r: r, w: w, x: x }
-
--- | Create a `Perms` value. The arguments represent the user's, group's, and
--- | others' permission sets, respectively.
+-- | Create a `Perms` value. The arguments represent the owner's, group's, and
+-- | other users' permission sets, respectively.
 mkPerms :: Perm -> Perm -> Perm -> Perms
 mkPerms u g o = Perms { u: u, g: g, o: o }
 
@@ -96,10 +138,11 @@ mkPerms u g o = Perms { u: u, g: g, o: o }
 -- | * `permToInt w == 2`
 -- | * `permToInt (r <> w) == 6`
 permToInt :: Perm -> Int
-permToInt (Perm { r = r, w = w, x = x }) = fromNumber $
-    (if r then 4 else 0)
-  + (if w then 2 else 0)
-  + (if x then 1 else 0)
+permToInt (Perm { r = r, w = w, x = x }) =
+  fromNumber $
+      (if r then 4 else 0)
+    + (if w then 2 else 0)
+    + (if x then 1 else 0)
 
 -- | Convert a `Perm` to an octal string, via `permToInt`.
 permToString :: Perm -> String
@@ -116,14 +159,6 @@ permsToString (Perms { u = u, g = g, o = o }) =
   ++ permToString g
   ++ permToString o
 
+-- | Convert a `Perms` value to an `Int`, via `permsToString`.
 permsToInt :: Perms -> Int
-permsToInt p = fromNumber $ readInt 8 $ permsToString p
-
-instance showPerm :: Show Perm where
-  show (Perm { r = r, w = w, x = x }) =
-       (if r then "r" else "-")
-    ++ (if w then "w" else "-")
-    ++ (if x then "x" else "-")
-
-instance showPerms :: Show Perms where
-  show (Perms { u = u, g = g, o = o }) = show u ++ show g ++ show o
+permsToInt = fromNumber <<< readInt 8 <<< permsToString

src/Node/FS/Sync.purs

@@ -247,7 +247,7 @@ rmdir file = mkEff $ \_ -> runFn1
 mkdir :: forall eff. FilePath
                   -> Eff (fs :: FS, err :: Exception | eff) Unit
 
-mkdir = flip mkdir' $ mkPerms (r <> w <> x) (r <> w <> x) (r <> w <> x)
+mkdir = flip mkdir' $ mkPerms all all all
 
 -- |
 -- Makes a new directory with the specified permissions.