update pathy

Author: safareli

bower.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "purescript-prelude": "^3.1.0",
     "purescript-matryoshka": "^0.3.0",
-    "purescript-pathy": "^4.0.0",
+    "purescript-pathy": "safareli/purescript-pathy#refactor",
     "purescript-profunctor": "^3.2.0",
     "purescript-profunctor-lenses": "^3.2.0",
     "purescript-ejson": "^10.0.1",

src/SqlSquared/Path.purs

@@ -10,43 +10,51 @@ module SqlSquared.Path
   ) where
 
 import Prelude
-import Data.Either as E
-import Data.NonEmpty ((:|))
-import Data.Path.Pathy as Pt
-import Data.Path.Pathy.Gen as PtGen
+
 import Control.Monad.Gen as Gen
 import Control.Monad.Rec.Class (class MonadRec)
+import Data.Either as E
+import Data.NonEmpty ((:|))
+import Pathy (posixParser, posixPrinter)
+import Pathy as Pt
+import Pathy.Gen as PtGen
 import SqlSquared.Utils ((∘))
 
-type AnyDirPath = E.Either (Pt.AbsDir Pt.Unsandboxed) (Pt.RelDir Pt.Unsandboxed)
-type AnyFilePath = E.Either (Pt.AbsFile Pt.Unsandboxed) (Pt.RelFile Pt.Unsandboxed)
+type AnyDirPath = E.Either Pt.AbsDir Pt.RelDir
+type AnyFilePath = E.Either Pt.AbsFile Pt.RelFile
 
 printAnyDirPath :: AnyDirPath -> String
-printAnyDirPath = E.either Pt.unsafePrintPath Pt.unsafePrintPath
+printAnyDirPath = E.either
+  (Pt.sandboxAny >>> Pt.unsafePrintPath posixPrinter)
+  (Pt.sandboxAny >>> Pt.unsafePrintPath posixPrinter)
 
 parseAnyDirPath :: forall m. Applicative m => (forall a. String -> m a) -> String -> m AnyDirPath
-parseAnyDirPath fail = Pt.parsePath
+parseAnyDirPath fail = Pt.parsePath posixParser
   (pure ∘ E.Right)
   (pure ∘ E.Left)
   (const $ fail "Expected a directory path")
   (const $ fail "Expected a directory path")
+  (fail "Expected valid path")
 
 printAnyFilePath :: AnyFilePath -> String
-printAnyFilePath = E.either Pt.unsafePrintPath Pt.unsafePrintPath
+printAnyFilePath = E.either
+  (Pt.sandboxAny >>> Pt.unsafePrintPath posixPrinter)
+  (Pt.sandboxAny >>> Pt.unsafePrintPath posixPrinter)
 
 parseAnyFilePath :: forall m. Applicative m => (forall a. String -> m a) -> String -> m AnyFilePath
-parseAnyFilePath fail = Pt.parsePath
+parseAnyFilePath fail = Pt.parsePath posixParser
   (const $ fail "Expected a file path")
   (const $ fail "Expected a file path")
   (pure ∘ E.Right)
   (pure ∘ E.Left)
+  (fail "Expected valid path")
 
 genAnyFilePath :: forall m. Gen.MonadGen m => MonadRec m => m AnyFilePath
 genAnyFilePath = Gen.oneOf
-  $ (E.Left ∘ Pt.unsandbox <$> PtGen.genAbsFilePath)
-  :| [E.Right ∘ Pt.unsandbox <$> PtGen.genRelFilePath]
+  $ (E.Left <$> PtGen.genAbsFilePath)
+  :| [E.Right <$> PtGen.genRelFilePath]
 
 genAnyDirPath :: forall m. Gen.MonadGen m => MonadRec m => m AnyDirPath
 genAnyDirPath = Gen.oneOf
-  $ (E.Left ∘ Pt.unsandbox <$> PtGen.genAbsDirPath)
-  :| [E.Right ∘ Pt.unsandbox <$> PtGen.genRelDirPath]
+  $ (E.Left <$> PtGen.genAbsDirPath)
+  :| [E.Right <$> PtGen.genRelDirPath]

test/src/Constructors.purs

@@ -2,16 +2,15 @@ module Test.Constructors where
 
 import Prelude
 
-import Data.List as L
+import Data.Either as E
 import Data.Lens ((.~), (<>~), (?~))
+import Data.List as L
 import Data.Maybe (Maybe(..))
 import Data.NonEmpty as NE
-import Data.Either as E
-import Data.Path.Pathy as Pt
-
+import Data.Symbol (SProxy(..))
+import Pathy as Pt
 import SqlSquared as S
 import SqlSquared.Utils ((×), (∘))
-
 import Test.Unit (suite, test, TestSuite)
 import Test.Unit.Assert as Assert
 
@@ -26,9 +25,9 @@ selectQuery =
         { alias: Nothing
         , path: E.Left
           $ Pt.rootDir
-          Pt.</> Pt.dir "mongo"
-          Pt.</> Pt.dir "testDb"
-          Pt.</> Pt.file "patients"
+          Pt.</> Pt.dir (SProxy :: SProxy "mongo")
+          Pt.</> Pt.dir (SProxy :: SProxy "testDb")
+          Pt.</> Pt.file (SProxy :: SProxy "patients")
         })
     ( Just $ S.binop S.Eq (S.ident "quux") (S.num 12.0) )
     ( Just $ S.groupBy [ S.ident "zzz" ] # S.having ( S.binop S.Gt (S.ident "ooo") ( S.int 2)) )
@@ -53,9 +52,9 @@ buildSelectQuery =
            { alias: Nothing
            , path: E.Left
              $ Pt.rootDir
-             Pt.</> Pt.dir "mongo"
-             Pt.</> Pt.dir "testDb"
-             Pt.</> Pt.file "patients"
+             Pt.</> Pt.dir (SProxy :: SProxy "mongo")
+             Pt.</> Pt.dir (SProxy :: SProxy "testDb")
+             Pt.</> Pt.file (SProxy :: SProxy "patients")
            }))
 
     ∘ (S._filter ?~ S.binop S.Eq (S.ident "quux") (S.num 12.0))