feat: working

test/Test/Main.purs

@@ -5,10 +5,10 @@ import Prelude
 import Data.Maybe (Maybe(..))
 import Effect (Effect)
 import Effect.Aff (launchAff_)
-import Test.Pipes.CSV as Test.Pipes.CSV
+import Test.Pipes.CBOR as Test.Pipes.CBOR
 import Test.Spec.Reporter (specReporter)
 import Test.Spec.Runner (defaultConfig, runSpec')
 
 main :: Effect Unit
 main = launchAff_ $ runSpec' (defaultConfig { failFast = true, timeout = Nothing }) [ specReporter ] do
-  Test.Pipes.CSV.spec
+  Test.Pipes.CBOR.spec

test/Test/Pipes.CSV.purs

@@ -1,88 +1,87 @@
-module Test.Pipes.CSV where
+module Test.Pipes.CBOR where
 
 import Prelude
 
+import Control.Monad.Cont (lift)
 import Control.Monad.Gen (chooseInt)
-import Control.Monad.Rec.Class (Step(..), tailRecM)
 import Data.Array as Array
 import Data.DateTime (DateTime)
-import Data.Foldable (fold, sum)
+import Data.List ((:))
+import Data.List as List
 import Data.Maybe (Maybe(..), fromJust)
 import Data.Newtype (wrap)
 import Data.PreciseDateTime (fromRFC3339String, toDateTimeLossy)
-import Data.String.CodePoints as String.CodePoints
 import Data.Tuple.Nested ((/\))
+import Effect (Effect)
+import Effect.Aff (delay)
+import Effect.CBOR as CBOR
 import Effect.Class (liftEffect)
-import Effect.Console (log)
+import Node.Buffer (Buffer)
+import Node.Buffer as Buffer
 import Node.Encoding (Encoding(..))
 import Partial.Unsafe (unsafePartial)
 import Pipes (yield, (>->))
-import Pipes.CSV as Pipes.CSV
+import Pipes.CBOR as Pipes.CBOR
 import Pipes.Collect as Pipes.Collect
-import Pipes.Construct as Pipes.Construct
-import Pipes.Node.Buffer as Pipes.Buffer
 import Pipes.Node.Stream as Pipes.Stream
-import Pipes.Prelude (chain, map, toListM) as Pipes
-import Pipes.Util as Pipes.Util
+import Pipes.Prelude (toListM) as Pipes
 import Test.QuickCheck.Gen (randomSample')
 import Test.Spec (Spec, before, describe, it)
 import Test.Spec.Assertions (shouldEqual)
 
-csv :: String
-csv =
-  """created,flag,foo,id
-2020-01-01T00:00:00.0Z,true,a,1
-2024-02-02T08:00:00.0Z,false,apple,2
-1970-01-01T00:00:00.0Z,true,hello,3
-"""
+cborHex :: String
+cborHex = "82b90002646e616d656568656e72796174c1fb41d990ee6d671aa0b90002646e616d65656a756c696f6174c1fbc1d756dad0bbb646"
+
+cborBuf :: Effect Buffer
+cborBuf = Buffer.fromString cborHex Hex
+
+exp :: Array {name :: String, t :: DateTime}
+exp =
+  [{name: "henry", t: toDateTimeLossy $ unsafePartial fromJust $ fromRFC3339String $ wrap "2024-05-14T19:21:25.611Z"}
+  ,{name: "julio", t: toDateTimeLossy $ unsafePartial fromJust $ fromRFC3339String $ wrap "1920-05-14T20:21:17.067Z"}
+  ]
+
 
 dt :: String -> DateTime
 dt = toDateTimeLossy <<< unsafePartial fromJust <<< fromRFC3339String <<< wrap
 
 spec :: Spec Unit
 spec =
-  describe "Pipes.CSV" do
-    it "stringify" do
-      let
-        objs =
-          [ { id: 1, foo: "a", flag: true, created: dt "2020-01-01T00:00:00Z" }
-          , { id: 2, foo: "apple", flag: false, created: dt "2024-02-02T08:00:00Z" }
-          , { id: 3, foo: "hello", flag: true, created: dt "1970-01-01T00:00:00Z" }
-          ]
+  describe "Pipes.CBOR" do
+    it "encode" do
+      bytes
+        <- Pipes.Collect.toBuffer
+          $ Pipes.Stream.withEOS (yield exp)
+             >-> Pipes.CBOR.encode
+             >-> Pipes.Stream.unEOS
+      act <- liftEffect $ CBOR.decode bytes
+      act `shouldEqual` exp
 
-      csv' <- map fold $ Pipes.Collect.toArray $ Pipes.Stream.withEOS (Pipes.Construct.eachArray objs) >-> Pipes.CSV.stringify >-> Pipes.Stream.unEOS
-      csv' `shouldEqual` csv
     describe "parse" do
       it "parses csv" do
-        rows <- map Array.fromFoldable
-          $ Pipes.toListM
-          $ Pipes.Stream.withEOS (yield csv)
-              >-> Pipes.Stream.inEOS (Pipes.Buffer.fromString UTF8)
-              >-> Pipes.CSV.parse
-              >-> Pipes.Stream.unEOS
+        buf <- liftEffect $ cborBuf
+        rows <- Pipes.toListM
+          $ Pipes.Stream.withEOS (yield buf *> lift (delay $ wrap 10.0))
+              >-> Pipes.CBOR.decode
 
-        rows `shouldEqual`
-          [ { id: 1, foo: "a", flag: true, created: dt "2020-01-01T00:00:00Z" }
-          , { id: 2, foo: "apple", flag: false, created: dt "2024-02-02T08:00:00Z" }
-          , { id: 3, foo: "hello", flag: true, created: dt "1970-01-01T00:00:00Z" }
-          ]
+        rows `shouldEqual` ((Just exp) : Nothing : List.Nil)
       before
         (do
           nums <- liftEffect $ randomSample' 100000 (chooseInt 0 9)
           let
-            chars = [ "i","d","\n" ] <> join ((\n -> [show n, "\n"]) <$> nums)
-          bufs <- Pipes.Collect.toArray
-            $ Pipes.Stream.withEOS (Pipes.Construct.eachArray chars)
-             >-> Pipes.Util.chunked 1000
-             >-> Pipes.Stream.inEOS (Pipes.map fold >-> Pipes.Buffer.fromString UTF8)
-             >-> Pipes.Stream.unEOS
-          pure $ nums /\ bufs
+            objs = (\n -> {id: n}) <$> nums
+          bytes <-
+            Pipes.Collect.toBuffer
+            $ Pipes.Stream.withEOS (yield objs)
+              >-> Pipes.CBOR.encode
+              >-> Pipes.Stream.unEOS
+          pure $ nums /\ bytes
         )
-        $ it "parses large csv" \(nums /\ bufs) -> do
+        $ it "parses large csv" \(nums /\ bytes) -> do
           rows <-
             Pipes.Collect.toArray
-              $ Pipes.Stream.withEOS (Pipes.Construct.eachArray bufs)
-                  >-> Pipes.CSV.parse @(id :: Int)
+              $ Pipes.Stream.withEOS (yield bytes)
+                  >-> Pipes.CBOR.decode @(Array {id :: Int})
                   >-> Pipes.Stream.unEOS
 
-          rows `shouldEqual` ((\id -> { id }) <$> nums)
+          rows `shouldEqual` [(\id -> { id }) <$> nums]