Add conduit parser

.gitignore

@@ -1,10 +1,15 @@
 TAGS
 cabal-dev
 dist
+dist-newstyle
 *sandbox*
 #*#
 *.*~
 specs
 samples
 .stack-work
-*.lock
+*.lock
+
+# nix
+result
+result-doc

Streamin.md

@@ -0,0 +1,31 @@
+Simple xlsx parser/writer, only basic functionality at the moment
+
+This is a draft PR so ya'll can see what I'm doing and have an opportunity to voice concerns early.
+
+I'm going to do reading from stream first (our company needs both reading and writing).
+I'll work on writing stream support once the reading is implemented.
+
+Okay the strat is to index by
+
+```
+SheetItem = {
+  cellRow
+  allKnownSheetStaticProps
+}
+
+XslxItem = {
+  sheetItem
+  allKnownStaticProps
+}
+
+result :: Conduit
+    ByteString -- Input
+    XslxItem -- Output
+    m 
+```
+
+ So the conduit pipes gets bytestring chuncks and produces XslxItems which contain a single excell row.
+ Nested within a sheet, nested within an excell item.
+ If we can figure out other properties before starting the stream we'll just add that information to the pipeline and copy it.
+
+ https://hackage.haskell.org/package/xml-conduit-1.9.0.0/docs/Text-XML-Stream-Parse.html

benchmarks/Stream.hs

@@ -0,0 +1,76 @@
+{-# LANGUAGE BangPatterns      #-}
+{-# LANGUAGE BlockArguments    #-}
+{-# LANGUAGE LambdaCase        #-}
+{-# LANGUAGE OverloadedStrings #-}
+module Main (main) where
+
+import           Codec.Xlsx
+import           Codec.Xlsx.Parser.Stream
+import           Conduit
+import qualified Conduit                  as C
+import           Criterion.Main
+import qualified Data.ByteString          as BS
+import qualified Data.ByteString.Lazy     as LB
+import qualified Data.Conduit.Combinators as C
+import           Data.Function
+import qualified Data.Map                 as Map
+import           Data.Text                (Text)
+import qualified Data.Text                as Text
+import qualified Data.Text.IO             as Text
+import           Debug.Trace
+import           Prelude                  hiding (foldl)
+
+celVal :: CellValue -> Text
+celVal  = \case
+  CellText x   -> x
+  CellDouble x -> Text.pack $ show x
+  CellBool x   -> Text.pack $ show x
+  CellRich x   -> Text.pack $ show x
+  CellError x  -> Text.pack $ show x
+
+format :: SheetItem -> Text
+format x = Text.pack $ show (_si_sheet x, _si_row_index x, maybe "" celVal . _cellValue <$> _si_cell_row x)
+
+parseFileStream :: FilePath -> IO ()
+parseFileStream filepath = do
+  input <-
+      sourceFile filepath
+    & readXlsxC
+    & runResourceT
+  _ <- runResourceT $ runConduit (parseConduit input)
+  pure ()
+  where
+    parseConduit
+      :: Monad m
+      => ConduitM a SheetItem m () 
+      -> ConduitM a Void m [SheetItem]
+    parseConduit input =
+         input
+      .| C.filter (("sheet1.xml" ==) . _si_sheet)
+      .| C.foldl (\a b -> a <> [b]) []
+
+parseFile :: FilePath -> IO ()
+parseFile filepath = do
+  contents <- LB.readFile filepath
+  let !_ = toXlsx contents
+  pure ()
+
+parseFileFast :: FilePath -> IO ()
+parseFileFast filepath = do
+  contents <- LB.readFile filepath
+  let !_ = toXlsxFast contents
+  pure ()
+
+main :: IO ()
+main = let
+  files =
+    [ "data/simple.xlsx"
+    , "data/testInput.xlsx"
+    , "data/6000.rows.x.26.cols.xlsx"
+    ]
+  benchFiles parse filename = bench ("parsing " <> filename) . nfIO $ parse filename
+  in defaultMain
+      [ bgroup "stream" $ benchFiles parseFileStream <$> files
+      , bgroup "canonical" $ benchFiles parseFile <$> files
+      , bgroup "canonical fast" $ benchFiles parseFileFast <$> files
+      ]

cabal.project.local

@@ -0,0 +1,7 @@
+with-compiler: ghc-8.8.4
+optimization: 2
+ignore-project: False
+library-profiling: False 
+executable-profiling: False 
+tests: True
+benchmarks: True

default.nix

@@ -0,0 +1,3 @@
+(import (fetchTarball https://github.com/edolstra/flake-compat/archive/master.tar.gz) {
+  src = ./.;
+}).defaultNix

flake.nix

@@ -0,0 +1,43 @@
+{
+  description = "xlsx";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs";
+    flake-utils.url = "github:numtide/flake-utils/5466c5bbece17adaab2d82fae80b46e807611bf3";
+    gitignore = {
+      url = "github:hercules-ci/gitignore.nix/211907489e9f198594c0eb0ca9256a1949c9d412";
+      flake = false;
+    };
+  };
+
+  outputs = { self, nixpkgs, flake-utils, gitignore }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        packageName = "xlsx";
+        compiler = "ghc884";
+
+        pkgs = nixpkgs.legacyPackages.${system};
+        jailbreakUnbreak = pkg:
+          pkgs.haskell.lib.doJailbreak (pkg.overrideAttrs (_: { meta = { }; }));
+
+        gitignore = pkgs.nix-gitignore.gitignoreSourcePure [ ./.gitignore ];
+
+      in {
+        packages.${packageName} =
+          pkgs.haskell.packages.${compiler}.callCabal2nix packageName (gitignore ./.) rec { };
+
+        defaultPackage = self.packages.${system}.${packageName};
+
+        devShell = pkgs.mkShell {
+          buildInputs = with pkgs; [
+            haskell-language-server
+            stylish-haskell
+            ghcid
+            zlib 
+            cabal-install
+          ];
+          inputsFrom = builtins.attrValues self.packages.${system};
+          # shellHook = "cabal v2-repl";
+        };
+      });
+}

shell.nix

@@ -0,0 +1 @@
+(import ./.).devShell."${builtins.currentSystem}"

src/Codec/Xlsx/Parser.hs

@@ -71,7 +71,7 @@ import Codec.Xlsx.Types.PivotTable.Internal
 toXlsx :: L.ByteString -> Xlsx
 toXlsx = either (error . show) id . toXlsxEither
 
-data ParseError = InvalidZipArchive
+data ParseError = InvalidZipArchive String
                 | MissingFile FilePath
                 | InvalidFile FilePath Text
                 | InvalidRef FilePath RefId
@@ -106,7 +106,7 @@ toXlsxEitherBase ::
   -> L.ByteString
   -> Parser Xlsx
 toXlsxEitherBase parseSheet bs = do
-  ar <- left (const InvalidZipArchive) $ Zip.toArchiveOrFail bs
+  ar <- left InvalidZipArchive $ Zip.toArchiveOrFail bs
   sst <- getSharedStrings ar
   contentTypes <- getContentTypes ar
   (wfs, names, cacheSources, dateBase) <- readWorkbook ar