{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE OverloadedStrings         #-}
{-# LANGUAGE PackageImports #-}
{-# LANGUAGE RecordWildCards           #-}
{-# LANGUAGE ScopedTypeVariables       #-}
{-# LANGUAGE TupleSections             #-}

-- | This module provides a function for reading .xlsx files
module Codec.Xlsx.Parser
  ( toXlsx
  , toXlsxEither
  , toXlsxFast
  , toXlsxEitherFast
  , ParseError(..)
  , Parser
  ) where

import qualified "zip-archive" Codec.Archive.Zip as Zip
import Control.Applicative
import Control.Arrow (left)
import Control.Error.Safe (headErr)
import Control.Error.Util (note)
import Control.Exception (Exception)
#ifdef USE_MICROLENS
import Lens.Micro
#else
import Control.Lens hiding ((<.>), element, views)
#endif
import Control.Monad (join, void)
import Control.Monad.Except (catchError, throwError)
import Data.Bool (bool)
import Data.ByteString (ByteString)
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Lazy as LB
import Data.ByteString.Lazy.Char8 ()
import Data.List
import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe
import Data.Monoid
import Data.Text (Text)
import qualified Data.Text as T
import Data.Traversable
import GHC.Generics (Generic)
import Prelude hiding (sequence)
import Safe (headNote)
import System.FilePath.Posix
import Text.XML as X
import Text.XML.Cursor hiding (bool)
import qualified Xeno.DOM as Xeno

import Codec.Xlsx.Parser.Internal
import Codec.Xlsx.Parser.Internal.PivotTable
import Codec.Xlsx.Types
import Codec.Xlsx.Types.Cell (formulaDataFromCursor)
import Codec.Xlsx.Types.Internal
import Codec.Xlsx.Types.Internal.CfPair
import Codec.Xlsx.Types.Internal.CommentTable as CommentTable
import Codec.Xlsx.Types.Internal.ContentTypes as ContentTypes
import Codec.Xlsx.Types.Internal.CustomProperties
       as CustomProperties
import Codec.Xlsx.Types.Internal.DvPair
import Codec.Xlsx.Types.Internal.FormulaData
import Codec.Xlsx.Types.Internal.Relationships as Relationships
import Codec.Xlsx.Types.Internal.SharedStringTable
import Codec.Xlsx.Types.PivotTable.Internal

-- | Reads `Xlsx' from raw data (lazy bytestring)
toXlsx :: L.ByteString -> Xlsx
toXlsx :: ByteString -> Xlsx
toXlsx = (ParseError -> Xlsx)
-> (Xlsx -> Xlsx) -> Either ParseError Xlsx -> Xlsx
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ([Char] -> Xlsx
forall a. Partial => [Char] -> a
error ([Char] -> Xlsx) -> (ParseError -> [Char]) -> ParseError -> Xlsx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> [Char]
forall a. Show a => a -> [Char]
show) Xlsx -> Xlsx
forall a. a -> a
id (Either ParseError Xlsx -> Xlsx)
-> (ByteString -> Either ParseError Xlsx) -> ByteString -> Xlsx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either ParseError Xlsx
toXlsxEither

data ParseError = InvalidZipArchive String
                | MissingFile FilePath
                | InvalidFile FilePath Text
                | InvalidRef FilePath RefId
                | InconsistentXlsx Text
                deriving (ParseError -> ParseError -> Bool
(ParseError -> ParseError -> Bool)
-> (ParseError -> ParseError -> Bool) -> Eq ParseError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParseError -> ParseError -> Bool
== :: ParseError -> ParseError -> Bool
$c/= :: ParseError -> ParseError -> Bool
/= :: ParseError -> ParseError -> Bool
Eq, Int -> ParseError -> ShowS
[ParseError] -> ShowS
ParseError -> [Char]
(Int -> ParseError -> ShowS)
-> (ParseError -> [Char])
-> ([ParseError] -> ShowS)
-> Show ParseError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ParseError -> ShowS
showsPrec :: Int -> ParseError -> ShowS
$cshow :: ParseError -> [Char]
show :: ParseError -> [Char]
$cshowList :: [ParseError] -> ShowS
showList :: [ParseError] -> ShowS
Show, (forall x. ParseError -> Rep ParseError x)
-> (forall x. Rep ParseError x -> ParseError) -> Generic ParseError
forall x. Rep ParseError x -> ParseError
forall x. ParseError -> Rep ParseError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ParseError -> Rep ParseError x
from :: forall x. ParseError -> Rep ParseError x
$cto :: forall x. Rep ParseError x -> ParseError
to :: forall x. Rep ParseError x -> ParseError
Generic)

instance Exception ParseError

type Parser = Either ParseError

-- | Reads `Xlsx' from raw data (lazy bytestring) using @xeno@ library
-- using some "cheating":
--
-- * not doing 100% xml validation
-- * replacing only <https://www.w3.org/TR/REC-xml/#sec-predefined-ent predefined entities>
--   and <https://www.w3.org/TR/REC-xml/#NT-CharRef Unicode character references>
--   (without checking codepoint validity)
-- * almost not using XML namespaces
toXlsxFast :: L.ByteString -> Xlsx
toXlsxFast :: ByteString -> Xlsx
toXlsxFast = (ParseError -> Xlsx)
-> (Xlsx -> Xlsx) -> Either ParseError Xlsx -> Xlsx
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ([Char] -> Xlsx
forall a. Partial => [Char] -> a
error ([Char] -> Xlsx) -> (ParseError -> [Char]) -> ParseError -> Xlsx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> [Char]
forall a. Show a => a -> [Char]
show) Xlsx -> Xlsx
forall a. a -> a
id (Either ParseError Xlsx -> Xlsx)
-> (ByteString -> Either ParseError Xlsx) -> ByteString -> Xlsx
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either ParseError Xlsx
toXlsxEitherFast

-- | Reads `Xlsx' from raw data (lazy bytestring), failing with 'Left' on parse error
toXlsxEither :: L.ByteString -> Parser Xlsx
toXlsxEither :: ByteString -> Either ParseError Xlsx
toXlsxEither = (Archive
 -> SharedStringTable
 -> ContentTypes
 -> Caches
 -> WorksheetFile
 -> Parser Worksheet)
-> ByteString -> Either ParseError Xlsx
toXlsxEitherBase Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
extractSheet

-- | Fast parsing with 'Left' on parse error, see 'toXlsxFast'
toXlsxEitherFast :: L.ByteString -> Parser Xlsx
toXlsxEitherFast :: ByteString -> Either ParseError Xlsx
toXlsxEitherFast = (Archive
 -> SharedStringTable
 -> ContentTypes
 -> Caches
 -> WorksheetFile
 -> Parser Worksheet)
-> ByteString -> Either ParseError Xlsx
toXlsxEitherBase Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
extractSheetFast

toXlsxEitherBase ::
     (Zip.Archive -> SharedStringTable -> ContentTypes -> Caches -> WorksheetFile -> Parser Worksheet)
  -> L.ByteString
  -> Parser Xlsx
toXlsxEitherBase :: (Archive
 -> SharedStringTable
 -> ContentTypes
 -> Caches
 -> WorksheetFile
 -> Parser Worksheet)
-> ByteString -> Either ParseError Xlsx
toXlsxEitherBase Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
parseSheet ByteString
bs = do
  Archive
ar <- ([Char] -> ParseError)
-> Either [Char] Archive -> Either ParseError Archive
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left [Char] -> ParseError
InvalidZipArchive (Either [Char] Archive -> Either ParseError Archive)
-> Either [Char] Archive -> Either ParseError Archive
forall a b. (a -> b) -> a -> b
$ ByteString -> Either [Char] Archive
Zip.toArchiveOrFail ByteString
bs
  SharedStringTable
sst <- Archive -> Parser SharedStringTable
getSharedStrings Archive
ar
  ContentTypes
contentTypes <- Archive -> Parser ContentTypes
getContentTypes Archive
ar
  ([WorksheetFile]
wfs, DefinedNames
names, Caches
cacheSources, DateBase
dateBase) <- Archive -> Parser ([WorksheetFile], DefinedNames, Caches, DateBase)
readWorkbook Archive
ar
  [(Text, Worksheet)]
sheets <- [WorksheetFile]
-> (WorksheetFile -> Either ParseError (Text, Worksheet))
-> Either ParseError [(Text, Worksheet)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [WorksheetFile]
wfs ((WorksheetFile -> Either ParseError (Text, Worksheet))
 -> Either ParseError [(Text, Worksheet)])
-> (WorksheetFile -> Either ParseError (Text, Worksheet))
-> Either ParseError [(Text, Worksheet)]
forall a b. (a -> b) -> a -> b
$ \WorksheetFile
wf -> do
      Worksheet
sheet <- Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
parseSheet Archive
ar SharedStringTable
sst ContentTypes
contentTypes Caches
cacheSources WorksheetFile
wf
      (Text, Worksheet) -> Either ParseError (Text, Worksheet)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Text, Worksheet) -> Either ParseError (Text, Worksheet))
-> (Worksheet -> (Text, Worksheet))
-> Worksheet
-> Either ParseError (Text, Worksheet)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (WorksheetFile -> Text
wfName WorksheetFile
wf,) (Worksheet -> (Text, Worksheet))
-> (Worksheet -> Worksheet) -> Worksheet -> (Text, Worksheet)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((SheetState -> Identity SheetState)
-> Worksheet -> Identity Worksheet
Lens' Worksheet SheetState
wsState ((SheetState -> Identity SheetState)
 -> Worksheet -> Identity Worksheet)
-> SheetState -> Worksheet -> Worksheet
forall s t a b. ASetter s t a b -> b -> s -> t
.~ WorksheetFile -> SheetState
wfState WorksheetFile
wf) (Worksheet -> Either ParseError (Text, Worksheet))
-> Worksheet -> Either ParseError (Text, Worksheet)
forall a b. (a -> b) -> a -> b
$ Worksheet
sheet
  CustomProperties Map Text Variant
customPropMap <- Archive -> Parser CustomProperties
getCustomProperties Archive
ar
  Xlsx -> Either ParseError Xlsx
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Xlsx -> Either ParseError Xlsx) -> Xlsx -> Either ParseError Xlsx
forall a b. (a -> b) -> a -> b
$ [(Text, Worksheet)]
-> Styles -> DefinedNames -> Map Text Variant -> DateBase -> Xlsx
Xlsx [(Text, Worksheet)]
sheets (Archive -> Styles
getStyles Archive
ar) DefinedNames
names Map Text Variant
customPropMap DateBase
dateBase

data WorksheetFile = WorksheetFile { WorksheetFile -> Text
wfName :: Text
                                   , WorksheetFile -> SheetState
wfState :: SheetState
                                   , WorksheetFile -> [Char]
wfPath :: FilePath
                                   }
                   deriving (Int -> WorksheetFile -> ShowS
[WorksheetFile] -> ShowS
WorksheetFile -> [Char]
(Int -> WorksheetFile -> ShowS)
-> (WorksheetFile -> [Char])
-> ([WorksheetFile] -> ShowS)
-> Show WorksheetFile
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WorksheetFile -> ShowS
showsPrec :: Int -> WorksheetFile -> ShowS
$cshow :: WorksheetFile -> [Char]
show :: WorksheetFile -> [Char]
$cshowList :: [WorksheetFile] -> ShowS
showList :: [WorksheetFile] -> ShowS
Show, (forall x. WorksheetFile -> Rep WorksheetFile x)
-> (forall x. Rep WorksheetFile x -> WorksheetFile)
-> Generic WorksheetFile
forall x. Rep WorksheetFile x -> WorksheetFile
forall x. WorksheetFile -> Rep WorksheetFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WorksheetFile -> Rep WorksheetFile x
from :: forall x. WorksheetFile -> Rep WorksheetFile x
$cto :: forall x. Rep WorksheetFile x -> WorksheetFile
to :: forall x. Rep WorksheetFile x -> WorksheetFile
Generic)

type Caches = [(CacheId, (Text, CellRef, [CacheField]))]

extractSheetFast :: Zip.Archive
                 -> SharedStringTable
                 -> ContentTypes
                 -> Caches
                 -> WorksheetFile
                 -> Parser Worksheet
extractSheetFast :: Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
extractSheetFast Archive
ar SharedStringTable
sst ContentTypes
contentTypes Caches
caches WorksheetFile
wf = do
  ByteString
file <-
    ParseError -> Maybe ByteString -> Either ParseError ByteString
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
filePath) (Maybe ByteString -> Either ParseError ByteString)
-> Maybe ByteString -> Either ParseError ByteString
forall a b. (a -> b) -> a -> b
$
    Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
filePath Archive
ar
  Relationships
sheetRels <- Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
filePath
  Node
root <-
    (XenoException -> ParseError)
-> Either XenoException Node -> Either ParseError Node
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\XenoException
ex -> [Char] -> Text -> ParseError
InvalidFile [Char]
filePath (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack (XenoException -> [Char]
forall a. Show a => a -> [Char]
show XenoException
ex)) (Either XenoException Node -> Either ParseError Node)
-> Either XenoException Node -> Either ParseError Node
forall a b. (a -> b) -> a -> b
$
    ByteString -> Either XenoException Node
Xeno.parse (ByteString -> ByteString
LB.toStrict ByteString
file)
  Node -> Relationships -> Parser Worksheet
parseWorksheet Node
root Relationships
sheetRels
  where
    filePath :: [Char]
filePath = WorksheetFile -> [Char]
wfPath WorksheetFile
wf
    parseWorksheet :: Xeno.Node -> Relationships -> Parser Worksheet
    parseWorksheet :: Node -> Relationships -> Parser Worksheet
parseWorksheet Node
root Relationships
sheetRels = do
      let prefixes :: NsPrefixes
prefixes = Node -> NsPrefixes
nsPrefixes Node
root
          odrNs :: a
odrNs =
            a
"http://schemas.openxmlformats.org/officeDocument/2006/relationships"
          odrX :: ByteString -> ByteString
odrX = NsPrefixes -> ByteString -> ByteString -> ByteString
addPrefix NsPrefixes
prefixes ByteString
forall {a}. IsString a => a
odrNs
          skip :: ByteString -> ChildCollector ()
skip = ChildCollector (Maybe Node) -> ChildCollector ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ChildCollector (Maybe Node) -> ChildCollector ())
-> (ByteString -> ChildCollector (Maybe Node))
-> ByteString
-> ChildCollector ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ChildCollector (Maybe Node)
maybeChild
      (Worksheet
ws, [RefId]
tableIds, Maybe RefId
drawingRId, Maybe RefId
legacyDrRId) <-
        Either Text (Worksheet, [RefId], Maybe RefId, Maybe RefId)
-> Parser (Worksheet, [RefId], Maybe RefId, Maybe RefId)
forall a. Either Text a -> Parser a
liftEither (Either Text (Worksheet, [RefId], Maybe RefId, Maybe RefId)
 -> Parser (Worksheet, [RefId], Maybe RefId, Maybe RefId))
-> (ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
    -> Either Text (Worksheet, [RefId], Maybe RefId, Maybe RefId))
-> ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
-> Parser (Worksheet, [RefId], Maybe RefId, Maybe RefId)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Node
-> ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
-> Either Text (Worksheet, [RefId], Maybe RefId, Maybe RefId)
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
root (ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
 -> Parser (Worksheet, [RefId], Maybe RefId, Maybe RefId))
-> ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
-> Parser (Worksheet, [RefId], Maybe RefId, Maybe RefId)
forall a b. (a -> b) -> a -> b
$ do
          ByteString -> ChildCollector ()
skip ByteString
"sheetPr"
          ByteString -> ChildCollector ()
skip ByteString
"dimension"
          Maybe [SheetView]
_wsSheetViews <- (Maybe [SheetView] -> Maybe [SheetView])
-> ChildCollector (Maybe [SheetView])
-> ChildCollector (Maybe [SheetView])
forall a b. (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe [SheetView] -> Maybe [SheetView]
forall {a}. Maybe [a] -> Maybe [a]
justNonEmpty (ChildCollector (Maybe [SheetView])
 -> ChildCollector (Maybe [SheetView]))
-> ((Node -> Either Text [SheetView])
    -> ChildCollector (Maybe [SheetView]))
-> (Node -> Either Text [SheetView])
-> ChildCollector (Maybe [SheetView])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> (Node -> Either Text [SheetView])
-> ChildCollector (Maybe [SheetView])
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"sheetViews" ((Node -> Either Text [SheetView])
 -> ChildCollector (Maybe [SheetView]))
-> (Node -> Either Text [SheetView])
-> ChildCollector (Maybe [SheetView])
forall a b. (a -> b) -> a -> b
$ \Node
n ->
            Node -> ChildCollector [SheetView] -> Either Text [SheetView]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ChildCollector [SheetView] -> Either Text [SheetView])
-> ChildCollector [SheetView] -> Either Text [SheetView]
forall a b. (a -> b) -> a -> b
$ ByteString -> ChildCollector [SheetView]
forall a. FromXenoNode a => ByteString -> ChildCollector [a]
fromChildList ByteString
"sheetView"
          ByteString -> ChildCollector ()
skip ByteString
"sheetFormatPr"
          [ColumnsProperties]
_wsColumnsProperties <-
            (Maybe [ColumnsProperties] -> [ColumnsProperties])
-> ChildCollector (Maybe [ColumnsProperties])
-> ChildCollector [ColumnsProperties]
forall a b. (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([ColumnsProperties]
-> Maybe [ColumnsProperties] -> [ColumnsProperties]
forall a. a -> Maybe a -> a
fromMaybe []) (ChildCollector (Maybe [ColumnsProperties])
 -> ChildCollector [ColumnsProperties])
-> ((Node -> Either Text [ColumnsProperties])
    -> ChildCollector (Maybe [ColumnsProperties]))
-> (Node -> Either Text [ColumnsProperties])
-> ChildCollector [ColumnsProperties]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> (Node -> Either Text [ColumnsProperties])
-> ChildCollector (Maybe [ColumnsProperties])
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"cols" ((Node -> Either Text [ColumnsProperties])
 -> ChildCollector [ColumnsProperties])
-> (Node -> Either Text [ColumnsProperties])
-> ChildCollector [ColumnsProperties]
forall a b. (a -> b) -> a -> b
$ \Node
n ->
              Node
-> ChildCollector [ColumnsProperties]
-> Either Text [ColumnsProperties]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ByteString -> ChildCollector [ColumnsProperties]
forall a. FromXenoNode a => ByteString -> ChildCollector [a]
fromChildList ByteString
"col")
          (Map RowIndex RowProperties
_wsRowPropertiesMap, CellMap
_wsCells, Map SharedFormulaIndex SharedFormulaOptions
_wsSharedFormulas) <-
            ByteString
-> (Node
    -> Either
         Text
         (Map RowIndex RowProperties, CellMap,
          Map SharedFormulaIndex SharedFormulaOptions))
-> ChildCollector
     (Map RowIndex RowProperties, CellMap,
      Map SharedFormulaIndex SharedFormulaOptions)
forall a. ByteString -> (Node -> Either Text a) -> ChildCollector a
requireAndParse ByteString
"sheetData" ((Node
  -> Either
       Text
       (Map RowIndex RowProperties, CellMap,
        Map SharedFormulaIndex SharedFormulaOptions))
 -> ChildCollector
      (Map RowIndex RowProperties, CellMap,
       Map SharedFormulaIndex SharedFormulaOptions))
-> (Node
    -> Either
         Text
         (Map RowIndex RowProperties, CellMap,
          Map SharedFormulaIndex SharedFormulaOptions))
-> ChildCollector
     (Map RowIndex RowProperties, CellMap,
      Map SharedFormulaIndex SharedFormulaOptions)
forall a b. (a -> b) -> a -> b
$ \Node
n -> do
              [Node]
rows <- Node -> ChildCollector [Node] -> Either Text [Node]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ChildCollector [Node] -> Either Text [Node])
-> ChildCollector [Node] -> Either Text [Node]
forall a b. (a -> b) -> a -> b
$ ByteString -> ChildCollector [Node]
childList ByteString
"row"
              [(RowIndex, Maybe RowProperties,
  [(RowIndex, ColumnIndex, Cell,
    Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
forall {t :: * -> *}.
Foldable t =>
t (RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRows ([(RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions))
-> Either
     Text
     [(RowIndex, Maybe RowProperties,
       [(RowIndex, ColumnIndex, Cell,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
-> Either
     Text
     (Map RowIndex RowProperties, CellMap,
      Map SharedFormulaIndex SharedFormulaOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Node]
-> (Node
    -> Either
         Text
         (RowIndex, Maybe RowProperties,
          [(RowIndex, ColumnIndex, Cell,
            Maybe (SharedFormulaIndex, SharedFormulaOptions))]))
-> Either
     Text
     [(RowIndex, Maybe RowProperties,
       [(RowIndex, ColumnIndex, Cell,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Node]
rows Node
-> Either
     Text
     (RowIndex, Maybe RowProperties,
      [(RowIndex, ColumnIndex, Cell,
        Maybe (SharedFormulaIndex, SharedFormulaOptions))])
parseRow
          ByteString -> ChildCollector ()
skip ByteString
"sheetCalcPr"
          Maybe SheetProtection
_wsProtection <- ByteString -> ChildCollector (Maybe SheetProtection)
forall a. FromXenoNode a => ByteString -> ChildCollector (Maybe a)
maybeFromChild ByteString
"sheetProtection"
          ByteString -> ChildCollector ()
skip ByteString
"protectedRanges"
          ByteString -> ChildCollector ()
skip ByteString
"scenarios"
          Maybe AutoFilter
_wsAutoFilter <- ByteString -> ChildCollector (Maybe AutoFilter)
forall a. FromXenoNode a => ByteString -> ChildCollector (Maybe a)
maybeFromChild ByteString
"autoFilter"
          ByteString -> ChildCollector ()
skip ByteString
"sortState"
          ByteString -> ChildCollector ()
skip ByteString
"dataConsolidate"
          ByteString -> ChildCollector ()
skip ByteString
"customSheetViews"
          [Range]
_wsMerges <- (Maybe [Range] -> [Range])
-> ChildCollector (Maybe [Range]) -> ChildCollector [Range]
forall a b. (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Range] -> Maybe [Range] -> [Range]
forall a. a -> Maybe a -> a
fromMaybe []) (ChildCollector (Maybe [Range]) -> ChildCollector [Range])
-> ((Node -> Either Text [Range])
    -> ChildCollector (Maybe [Range]))
-> (Node -> Either Text [Range])
-> ChildCollector [Range]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> (Node -> Either Text [Range]) -> ChildCollector (Maybe [Range])
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"mergeCells" ((Node -> Either Text [Range]) -> ChildCollector [Range])
-> (Node -> Either Text [Range]) -> ChildCollector [Range]
forall a b. (a -> b) -> a -> b
$ \Node
n -> do
            [Node]
mCells <- Node -> ChildCollector [Node] -> Either Text [Node]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ChildCollector [Node] -> Either Text [Node])
-> ChildCollector [Node] -> Either Text [Node]
forall a b. (a -> b) -> a -> b
$ ByteString -> ChildCollector [Node]
childList ByteString
"mergeCell"
            [Node] -> (Node -> Either Text Range) -> Either Text [Range]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Node]
mCells ((Node -> Either Text Range) -> Either Text [Range])
-> (Node -> Either Text Range) -> Either Text [Range]
forall a b. (a -> b) -> a -> b
$ \Node
mCell -> Node -> AttrParser Range -> Either Text Range
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
mCell (AttrParser Range -> Either Text Range)
-> AttrParser Range -> Either Text Range
forall a b. (a -> b) -> a -> b
$ ByteString -> AttrParser Range
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr ByteString
"ref"
          Map SqRef ConditionalFormatting
_wsConditionalFormattings <-
            [(SqRef, ConditionalFormatting)] -> Map SqRef ConditionalFormatting
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SqRef, ConditionalFormatting)]
 -> Map SqRef ConditionalFormatting)
-> ([CfPair] -> [(SqRef, ConditionalFormatting)])
-> [CfPair]
-> Map SqRef ConditionalFormatting
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CfPair -> (SqRef, ConditionalFormatting))
-> [CfPair] -> [(SqRef, ConditionalFormatting)]
forall a b. (a -> b) -> [a] -> [b]
map CfPair -> (SqRef, ConditionalFormatting)
unCfPair ([CfPair] -> Map SqRef ConditionalFormatting)
-> ChildCollector [CfPair]
-> ChildCollector (Map SqRef ConditionalFormatting)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ChildCollector [CfPair]
forall a. FromXenoNode a => ByteString -> ChildCollector [a]
fromChildList ByteString
"conditionalFormatting"
          Map SqRef DataValidation
_wsDataValidations <-
            (Maybe (Map SqRef DataValidation) -> Map SqRef DataValidation)
-> ChildCollector (Maybe (Map SqRef DataValidation))
-> ChildCollector (Map SqRef DataValidation)
forall a b. (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map SqRef DataValidation
-> Maybe (Map SqRef DataValidation) -> Map SqRef DataValidation
forall a. a -> Maybe a -> a
fromMaybe Map SqRef DataValidation
forall a. Monoid a => a
mempty) (ChildCollector (Maybe (Map SqRef DataValidation))
 -> ChildCollector (Map SqRef DataValidation))
-> ((Node -> Either Text (Map SqRef DataValidation))
    -> ChildCollector (Maybe (Map SqRef DataValidation)))
-> (Node -> Either Text (Map SqRef DataValidation))
-> ChildCollector (Map SqRef DataValidation)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> (Node -> Either Text (Map SqRef DataValidation))
-> ChildCollector (Maybe (Map SqRef DataValidation))
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"dataValidations" ((Node -> Either Text (Map SqRef DataValidation))
 -> ChildCollector (Map SqRef DataValidation))
-> (Node -> Either Text (Map SqRef DataValidation))
-> ChildCollector (Map SqRef DataValidation)
forall a b. (a -> b) -> a -> b
$ \Node
n -> do
              [(SqRef, DataValidation)] -> Map SqRef DataValidation
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SqRef, DataValidation)] -> Map SqRef DataValidation)
-> ([DvPair] -> [(SqRef, DataValidation)])
-> [DvPair]
-> Map SqRef DataValidation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DvPair -> (SqRef, DataValidation))
-> [DvPair] -> [(SqRef, DataValidation)]
forall a b. (a -> b) -> [a] -> [b]
map DvPair -> (SqRef, DataValidation)
unDvPair ([DvPair] -> Map SqRef DataValidation)
-> Either Text [DvPair] -> Either Text (Map SqRef DataValidation)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                Node -> ChildCollector [DvPair] -> Either Text [DvPair]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ByteString -> ChildCollector [DvPair]
forall a. FromXenoNode a => ByteString -> ChildCollector [a]
fromChildList ByteString
"dataValidation")
          ByteString -> ChildCollector ()
skip ByteString
"hyperlinks"
          ByteString -> ChildCollector ()
skip ByteString
"printOptions"
          ByteString -> ChildCollector ()
skip ByteString
"pageMargins"
          Maybe PageSetup
_wsPageSetup <- ByteString -> ChildCollector (Maybe PageSetup)
forall a. FromXenoNode a => ByteString -> ChildCollector (Maybe a)
maybeFromChild ByteString
"pageSetup"
          ByteString -> ChildCollector ()
skip ByteString
"headerFooter"
          ByteString -> ChildCollector ()
skip ByteString
"rowBreaks"
          ByteString -> ChildCollector ()
skip ByteString
"colBreaks"
          ByteString -> ChildCollector ()
skip ByteString
"customProperties"
          ByteString -> ChildCollector ()
skip ByteString
"cellWatches"
          ByteString -> ChildCollector ()
skip ByteString
"ignoredErrors"
          ByteString -> ChildCollector ()
skip ByteString
"smartTags"
          Maybe RefId
drawingRId <- ByteString
-> (Node -> Either Text RefId) -> ChildCollector (Maybe RefId)
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"drawing" ((Node -> Either Text RefId) -> ChildCollector (Maybe RefId))
-> (Node -> Either Text RefId) -> ChildCollector (Maybe RefId)
forall a b. (a -> b) -> a -> b
$ \Node
n ->
            Node -> AttrParser RefId -> Either Text RefId
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
n (AttrParser RefId -> Either Text RefId)
-> AttrParser RefId -> Either Text RefId
forall a b. (a -> b) -> a -> b
$ ByteString -> AttrParser RefId
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr (ByteString -> ByteString
odrX ByteString
"id")
          Maybe RefId
legacyDrRId <- ByteString
-> (Node -> Either Text RefId) -> ChildCollector (Maybe RefId)
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"legacyDrawing" ((Node -> Either Text RefId) -> ChildCollector (Maybe RefId))
-> (Node -> Either Text RefId) -> ChildCollector (Maybe RefId)
forall a b. (a -> b) -> a -> b
$ \Node
n ->
            Node -> AttrParser RefId -> Either Text RefId
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
n (AttrParser RefId -> Either Text RefId)
-> AttrParser RefId -> Either Text RefId
forall a b. (a -> b) -> a -> b
$ ByteString -> AttrParser RefId
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr (ByteString -> ByteString
odrX ByteString
"id")
          [RefId]
tableIds <- (Maybe [RefId] -> [RefId])
-> ChildCollector (Maybe [RefId]) -> ChildCollector [RefId]
forall a b. (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([RefId] -> Maybe [RefId] -> [RefId]
forall a. a -> Maybe a -> a
fromMaybe []) (ChildCollector (Maybe [RefId]) -> ChildCollector [RefId])
-> ((Node -> Either Text [RefId])
    -> ChildCollector (Maybe [RefId]))
-> (Node -> Either Text [RefId])
-> ChildCollector [RefId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> (Node -> Either Text [RefId]) -> ChildCollector (Maybe [RefId])
forall a.
ByteString -> (Node -> Either Text a) -> ChildCollector (Maybe a)
maybeParse ByteString
"tableParts" ((Node -> Either Text [RefId]) -> ChildCollector [RefId])
-> (Node -> Either Text [RefId]) -> ChildCollector [RefId]
forall a b. (a -> b) -> a -> b
$ \Node
n -> do
            [Node]
tParts <- Node -> ChildCollector [Node] -> Either Text [Node]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
n (ChildCollector [Node] -> Either Text [Node])
-> ChildCollector [Node] -> Either Text [Node]
forall a b. (a -> b) -> a -> b
$ ByteString -> ChildCollector [Node]
childList ByteString
"tablePart"
            [Node] -> (Node -> Either Text RefId) -> Either Text [RefId]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Node]
tParts ((Node -> Either Text RefId) -> Either Text [RefId])
-> (Node -> Either Text RefId) -> Either Text [RefId]
forall a b. (a -> b) -> a -> b
$ \Node
part ->
              Node -> AttrParser RefId -> Either Text RefId
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
part (AttrParser RefId -> Either Text RefId)
-> AttrParser RefId -> Either Text RefId
forall a b. (a -> b) -> a -> b
$ ByteString -> AttrParser RefId
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr (ByteString -> ByteString
odrX ByteString
"id")

          -- all explicitly assigned fields filled below
          (Worksheet, [RefId], Maybe RefId, Maybe RefId)
-> ChildCollector (Worksheet, [RefId], Maybe RefId, Maybe RefId)
forall a. a -> ChildCollector a
forall (m :: * -> *) a. Monad m => a -> m a
return (
            Worksheet
            { _wsDrawing :: Maybe Drawing
_wsDrawing = Maybe Drawing
forall a. Maybe a
Nothing
            , _wsPivotTables :: [PivotTable]
_wsPivotTables = []
            , _wsTables :: [Table]
_wsTables = []
            , _wsState :: SheetState
_wsState = WorksheetFile -> SheetState
wfState WorksheetFile
wf
            , [Range]
[ColumnsProperties]
Maybe [SheetView]
Maybe SheetProtection
Maybe PageSetup
Maybe AutoFilter
CellMap
Map SqRef ConditionalFormatting
Map SqRef DataValidation
Map RowIndex RowProperties
Map SharedFormulaIndex SharedFormulaOptions
_wsSheetViews :: Maybe [SheetView]
_wsColumnsProperties :: [ColumnsProperties]
_wsRowPropertiesMap :: Map RowIndex RowProperties
_wsCells :: CellMap
_wsSharedFormulas :: Map SharedFormulaIndex SharedFormulaOptions
_wsProtection :: Maybe SheetProtection
_wsAutoFilter :: Maybe AutoFilter
_wsMerges :: [Range]
_wsConditionalFormattings :: Map SqRef ConditionalFormatting
_wsDataValidations :: Map SqRef DataValidation
_wsPageSetup :: Maybe PageSetup
_wsColumnsProperties :: [ColumnsProperties]
_wsRowPropertiesMap :: Map RowIndex RowProperties
_wsCells :: CellMap
_wsMerges :: [Range]
_wsSheetViews :: Maybe [SheetView]
_wsPageSetup :: Maybe PageSetup
_wsConditionalFormattings :: Map SqRef ConditionalFormatting
_wsDataValidations :: Map SqRef DataValidation
_wsAutoFilter :: Maybe AutoFilter
_wsProtection :: Maybe SheetProtection
_wsSharedFormulas :: Map SharedFormulaIndex SharedFormulaOptions
..
            }
            , [RefId]
tableIds
            , Maybe RefId
drawingRId
            , Maybe RefId
legacyDrRId)

      let commentsType :: a
commentsType = a
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
          commentTarget :: Maybe FilePath
          commentTarget :: Maybe [Char]
commentTarget = ShowS
logicalNameToZipItemName ShowS -> (Relationship -> [Char]) -> Relationship -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relationship -> [Char]
relTarget (Relationship -> [Char]) -> Maybe Relationship -> Maybe [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Relationships -> Maybe Relationship
findRelByType Text
forall {a}. IsString a => a
commentsType Relationships
sheetRels
          legacyDrPath :: Maybe [Char]
legacyDrPath = (Relationship -> [Char]) -> Maybe Relationship -> Maybe [Char]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ShowS
logicalNameToZipItemName ShowS -> (Relationship -> [Char]) -> Relationship -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relationship -> [Char]
relTarget) (Maybe Relationship -> Maybe [Char])
-> (RefId -> Maybe Relationship) -> RefId -> Maybe [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RefId -> Relationships -> Maybe Relationship)
-> Relationships -> RefId -> Maybe Relationship
forall a b c. (a -> b -> c) -> b -> a -> c
flip RefId -> Relationships -> Maybe Relationship
Relationships.lookup Relationships
sheetRels (RefId -> Maybe [Char]) -> Maybe RefId -> Maybe [Char]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe RefId
legacyDrRId
      Maybe CommentTable
commentsMap <-
        (Maybe (Maybe CommentTable) -> Maybe CommentTable)
-> Either ParseError (Maybe (Maybe CommentTable))
-> Either ParseError (Maybe CommentTable)
forall a b. (a -> b) -> Either ParseError a -> Either ParseError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (Maybe CommentTable) -> Maybe CommentTable
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (Either ParseError (Maybe (Maybe CommentTable))
 -> Either ParseError (Maybe CommentTable))
-> (([Char] -> Either ParseError (Maybe CommentTable))
    -> Either ParseError (Maybe (Maybe CommentTable)))
-> ([Char] -> Either ParseError (Maybe CommentTable))
-> Either ParseError (Maybe CommentTable)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe [Char]
-> ([Char] -> Either ParseError (Maybe CommentTable))
-> Either ParseError (Maybe (Maybe CommentTable))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM Maybe [Char]
commentTarget (([Char] -> Either ParseError (Maybe CommentTable))
 -> Either ParseError (Maybe CommentTable))
-> ([Char] -> Either ParseError (Maybe CommentTable))
-> Either ParseError (Maybe CommentTable)
forall a b. (a -> b) -> a -> b
$ Archive
-> Maybe [Char] -> [Char] -> Either ParseError (Maybe CommentTable)
getComments Archive
ar Maybe [Char]
legacyDrPath
      let commentCells :: CellMap
commentCells =
            [((RowIndex, ColumnIndex), Cell)] -> CellMap
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
            [ (Range -> (RowIndex, ColumnIndex)
fromSingleCellRefNoting Range
r, Cell
forall a. Default a => a
def { _cellComment = Just cmnt})
            | (Range
r, Comment
cmnt) <- [(Range, Comment)]
-> (CommentTable -> [(Range, Comment)])
-> Maybe CommentTable
-> [(Range, Comment)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] CommentTable -> [(Range, Comment)]
CommentTable.toList Maybe CommentTable
commentsMap
            ]
          assignComment :: Cell -> Cell -> Cell
assignComment Cell
withCmnt Cell
noCmnt =
            Cell
noCmnt Cell -> (Cell -> Cell) -> Cell
forall a b. a -> (a -> b) -> b
& (Maybe Comment -> Identity (Maybe Comment))
-> Cell -> Identity Cell
Lens' Cell (Maybe Comment)
cellComment ((Maybe Comment -> Identity (Maybe Comment))
 -> Cell -> Identity Cell)
-> Maybe Comment -> Cell -> Cell
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Cell
withCmnt Cell
-> Getting (Maybe Comment) Cell (Maybe Comment) -> Maybe Comment
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Comment) Cell (Maybe Comment)
Lens' Cell (Maybe Comment)
cellComment)
          mergeComments :: CellMap -> CellMap
mergeComments = (Cell -> Cell -> Cell) -> CellMap -> CellMap -> CellMap
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith Cell -> Cell -> Cell
assignComment CellMap
commentCells
      [Table]
tables <- [RefId]
-> (RefId -> Either ParseError Table) -> Either ParseError [Table]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [RefId]
tableIds ((RefId -> Either ParseError Table) -> Either ParseError [Table])
-> (RefId -> Either ParseError Table) -> Either ParseError [Table]
forall a b. (a -> b) -> a -> b
$ \RefId
rId -> do
        [Char]
fp <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
filePath Relationships
sheetRels RefId
rId
        Archive -> [Char] -> Either ParseError Table
getTable Archive
ar [Char]
fp
      Maybe Drawing
drawing <- Maybe RefId
-> (RefId -> Either ParseError Drawing)
-> Either ParseError (Maybe Drawing)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM Maybe RefId
drawingRId ((RefId -> Either ParseError Drawing)
 -> Either ParseError (Maybe Drawing))
-> (RefId -> Either ParseError Drawing)
-> Either ParseError (Maybe Drawing)
forall a b. (a -> b) -> a -> b
$ \RefId
dId -> do
        [Char]
fp <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
filePath Relationships
sheetRels RefId
dId
        Archive -> ContentTypes -> [Char] -> Either ParseError Drawing
getDrawing Archive
ar ContentTypes
contentTypes [Char]
fp
      let ptType :: a
ptType = a
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable"
      [PivotTable]
pivotTables <- [Relationship]
-> (Relationship -> Either ParseError PivotTable)
-> Either ParseError [PivotTable]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (Text -> Relationships -> [Relationship]
allByType Text
forall {a}. IsString a => a
ptType Relationships
sheetRels) ((Relationship -> Either ParseError PivotTable)
 -> Either ParseError [PivotTable])
-> (Relationship -> Either ParseError PivotTable)
-> Either ParseError [PivotTable]
forall a b. (a -> b) -> a -> b
$ \Relationship
rel -> do
        let ptPath :: [Char]
ptPath = ShowS
logicalNameToZipItemName ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Relationship -> [Char]
relTarget Relationship
rel
        ByteString
bs <- ParseError -> Maybe ByteString -> Either ParseError ByteString
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
ptPath) (Maybe ByteString -> Either ParseError ByteString)
-> Maybe ByteString -> Either ParseError ByteString
forall a b. (a -> b) -> a -> b
$ Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
ptPath Archive
ar
        ParseError -> Maybe PivotTable -> Either ParseError PivotTable
forall a b. a -> Maybe b -> Either a b
note (Text -> ParseError
InconsistentXlsx (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ Text
"Bad pivot table in " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack [Char]
ptPath) (Maybe PivotTable -> Either ParseError PivotTable)
-> Maybe PivotTable -> Either ParseError PivotTable
forall a b. (a -> b) -> a -> b
$
          (CacheId -> Maybe (Text, Range, [CacheField]))
-> ByteString -> Maybe PivotTable
parsePivotTable ((CacheId -> Caches -> Maybe (Text, Range, [CacheField]))
-> Caches -> CacheId -> Maybe (Text, Range, [CacheField])
forall a b c. (a -> b -> c) -> b -> a -> c
flip CacheId -> Caches -> Maybe (Text, Range, [CacheField])
forall a b. Eq a => a -> [(a, b)] -> Maybe b
Prelude.lookup Caches
caches) ByteString
bs

      Worksheet -> Parser Worksheet
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Worksheet -> Parser Worksheet) -> Worksheet -> Parser Worksheet
forall a b. (a -> b) -> a -> b
$ Worksheet
ws Worksheet -> (Worksheet -> Worksheet) -> Worksheet
forall a b. a -> (a -> b) -> b
& ([Table] -> Identity [Table]) -> Worksheet -> Identity Worksheet
Lens' Worksheet [Table]
wsTables (([Table] -> Identity [Table]) -> Worksheet -> Identity Worksheet)
-> [Table] -> Worksheet -> Worksheet
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Table]
tables
                  Worksheet -> (Worksheet -> Worksheet) -> Worksheet
forall a b. a -> (a -> b) -> b
& (CellMap -> Identity CellMap) -> Worksheet -> Identity Worksheet
Lens' Worksheet CellMap
wsCells ((CellMap -> Identity CellMap) -> Worksheet -> Identity Worksheet)
-> (CellMap -> CellMap) -> Worksheet -> Worksheet
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ CellMap -> CellMap
mergeComments
                  Worksheet -> (Worksheet -> Worksheet) -> Worksheet
forall a b. a -> (a -> b) -> b
& (Maybe Drawing -> Identity (Maybe Drawing))
-> Worksheet -> Identity Worksheet
Lens' Worksheet (Maybe Drawing)
wsDrawing ((Maybe Drawing -> Identity (Maybe Drawing))
 -> Worksheet -> Identity Worksheet)
-> Maybe Drawing -> Worksheet -> Worksheet
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe Drawing
drawing
                  Worksheet -> (Worksheet -> Worksheet) -> Worksheet
forall a b. a -> (a -> b) -> b
& ([PivotTable] -> Identity [PivotTable])
-> Worksheet -> Identity Worksheet
Lens' Worksheet [PivotTable]
wsPivotTables (([PivotTable] -> Identity [PivotTable])
 -> Worksheet -> Identity Worksheet)
-> [PivotTable] -> Worksheet -> Worksheet
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [PivotTable]
pivotTables
    liftEither :: Either Text a -> Parser a
    liftEither :: forall a. Either Text a -> Parser a
liftEither = (Text -> ParseError) -> Either Text a -> Either ParseError a
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\Text
t -> [Char] -> Text -> ParseError
InvalidFile [Char]
filePath Text
t)
    justNonEmpty :: Maybe [a] -> Maybe [a]
justNonEmpty v :: Maybe [a]
v@(Just (a
_:[a]
_)) = Maybe [a]
v
    justNonEmpty Maybe [a]
_ = Maybe [a]
forall a. Maybe a
Nothing
    collectRows :: t (RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRows = ((RowIndex, Maybe RowProperties,
  [(RowIndex, ColumnIndex, Cell,
    Maybe (SharedFormulaIndex, SharedFormulaOptions))])
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions)
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions))
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> t (RowIndex, Maybe RowProperties,
      [(RowIndex, ColumnIndex, Cell,
        Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRow (Map RowIndex RowProperties
forall k a. Map k a
M.empty, CellMap
forall k a. Map k a
M.empty, Map SharedFormulaIndex SharedFormulaOptions
forall k a. Map k a
M.empty)
    collectRow ::
         ( RowIndex
         , Maybe RowProperties
         , [(RowIndex, ColumnIndex, Cell, Maybe (SharedFormulaIndex, SharedFormulaOptions))])
      -> ( Map RowIndex RowProperties
         , CellMap
         , Map SharedFormulaIndex SharedFormulaOptions)
      -> ( Map RowIndex RowProperties
         , CellMap
         , Map SharedFormulaIndex SharedFormulaOptions)
    collectRow :: (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRow (RowIndex
r, Maybe RowProperties
mRP, [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
rowCells) (Map RowIndex RowProperties
rowMap, CellMap
cellMap, Map SharedFormulaIndex SharedFormulaOptions
sharedF) =
      let ([((RowIndex, ColumnIndex), Cell)]
newCells0, [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
newSharedF0) =
            [(((RowIndex, ColumnIndex), Cell),
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
-> ([((RowIndex, ColumnIndex), Cell)],
    [Maybe (SharedFormulaIndex, SharedFormulaOptions)])
forall a b. [(a, b)] -> ([a], [b])
unzip [(((RowIndex
rInd, ColumnIndex
cInd), Cell
cd), Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared) | (RowIndex
rInd, ColumnIndex
cInd, Cell
cd, Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared) <- [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
rowCells]
          newCells :: CellMap
newCells = [((RowIndex, ColumnIndex), Cell)] -> CellMap
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList [((RowIndex, ColumnIndex), Cell)]
newCells0
          newSharedF :: Map SharedFormulaIndex SharedFormulaOptions
newSharedF = [(SharedFormulaIndex, SharedFormulaOptions)]
-> Map SharedFormulaIndex SharedFormulaOptions
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(SharedFormulaIndex, SharedFormulaOptions)]
 -> Map SharedFormulaIndex SharedFormulaOptions)
-> [(SharedFormulaIndex, SharedFormulaOptions)]
-> Map SharedFormulaIndex SharedFormulaOptions
forall a b. (a -> b) -> a -> b
$ [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
-> [(SharedFormulaIndex, SharedFormulaOptions)]
forall a. [Maybe a] -> [a]
catMaybes [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
newSharedF0
          newRowMap :: Map RowIndex RowProperties
newRowMap =
            case Maybe RowProperties
mRP of
              Just RowProperties
rp -> RowIndex
-> RowProperties
-> Map RowIndex RowProperties
-> Map RowIndex RowProperties
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert RowIndex
r RowProperties
rp Map RowIndex RowProperties
rowMap
              Maybe RowProperties
Nothing -> Map RowIndex RowProperties
rowMap
      in (Map RowIndex RowProperties
newRowMap, CellMap
cellMap CellMap -> CellMap -> CellMap
forall a. Semigroup a => a -> a -> a
<> CellMap
newCells, Map SharedFormulaIndex SharedFormulaOptions
sharedF Map SharedFormulaIndex SharedFormulaOptions
-> Map SharedFormulaIndex SharedFormulaOptions
-> Map SharedFormulaIndex SharedFormulaOptions
forall a. Semigroup a => a -> a -> a
<> Map SharedFormulaIndex SharedFormulaOptions
newSharedF)
    parseRow ::
         Xeno.Node
      -> Either Text ( RowIndex
                     , Maybe RowProperties
                     , [( RowIndex
                        , ColumnIndex
                        , Cell
                        , Maybe (SharedFormulaIndex, SharedFormulaOptions))])
    parseRow :: Node
-> Either
     Text
     (RowIndex, Maybe RowProperties,
      [(RowIndex, ColumnIndex, Cell,
        Maybe (SharedFormulaIndex, SharedFormulaOptions))])
parseRow Node
row = do
      (Int
r, Maybe Int
s, Maybe Double
ht, Bool
cstHt, Bool
hidden) <-
        Node
-> AttrParser (Int, Maybe Int, Maybe Double, Bool, Bool)
-> Either Text (Int, Maybe Int, Maybe Double, Bool, Bool)
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
row (AttrParser (Int, Maybe Int, Maybe Double, Bool, Bool)
 -> Either Text (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser (Int, Maybe Int, Maybe Double, Bool, Bool)
-> Either Text (Int, Maybe Int, Maybe Double, Bool, Bool)
forall a b. (a -> b) -> a -> b
$
        ((,,,,) (Int
 -> Maybe Int
 -> Maybe Double
 -> Bool
 -> Bool
 -> (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser Int
-> AttrParser
     (Maybe Int
      -> Maybe Double
      -> Bool
      -> Bool
      -> (Int, Maybe Int, Maybe Double, Bool, Bool))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> AttrParser Int
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr ByteString
"r" AttrParser
  (Maybe Int
   -> Maybe Double
   -> Bool
   -> Bool
   -> (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser (Maybe Int)
-> AttrParser
     (Maybe Double
      -> Bool -> Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> AttrParser (Maybe Int)
forall a. FromAttrBs a => ByteString -> AttrParser (Maybe a)
maybeAttr ByteString
"s" AttrParser
  (Maybe Double
   -> Bool -> Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser (Maybe Double)
-> AttrParser
     (Bool -> Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> AttrParser (Maybe Double)
forall a. FromAttrBs a => ByteString -> AttrParser (Maybe a)
maybeAttr ByteString
"ht" AttrParser
  (Bool -> Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser Bool
-> AttrParser (Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
         ByteString -> Bool -> AttrParser Bool
forall a. FromAttrBs a => ByteString -> a -> AttrParser a
fromAttrDef ByteString
"customHeight" Bool
False AttrParser (Bool -> (Int, Maybe Int, Maybe Double, Bool, Bool))
-> AttrParser Bool
-> AttrParser (Int, Maybe Int, Maybe Double, Bool, Bool)
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
         ByteString -> Bool -> AttrParser Bool
forall a. FromAttrBs a => ByteString -> a -> AttrParser a
fromAttrDef ByteString
"hidden" Bool
False)
      let props :: RowProperties
props =
            RowProps
            { rowHeight :: Maybe RowHeight
rowHeight =
                if Bool
cstHt
                  then Double -> RowHeight
CustomHeight (Double -> RowHeight) -> Maybe Double -> Maybe RowHeight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Double
ht
                  else Double -> RowHeight
AutomaticHeight (Double -> RowHeight) -> Maybe Double -> Maybe RowHeight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Double
ht
            , rowStyle :: Maybe Int
rowStyle = Maybe Int
s
            , rowHidden :: Bool
rowHidden = Bool
hidden
            }
      [Node]
cellNodes <- Node -> ChildCollector [Node] -> Either Text [Node]
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
row (ChildCollector [Node] -> Either Text [Node])
-> ChildCollector [Node] -> Either Text [Node]
forall a b. (a -> b) -> a -> b
$ ByteString -> ChildCollector [Node]
childList ByteString
"c"
      [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
cells <- [Node]
-> (Node
    -> Either
         Text
         (RowIndex, ColumnIndex, Cell,
          Maybe (SharedFormulaIndex, SharedFormulaOptions)))
-> Either
     Text
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Node]
cellNodes Node
-> Either
     Text
     (RowIndex, ColumnIndex, Cell,
      Maybe (SharedFormulaIndex, SharedFormulaOptions))
parseCell
      (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> Either
     Text
     (RowIndex, Maybe RowProperties,
      [(RowIndex, ColumnIndex, Cell,
        Maybe (SharedFormulaIndex, SharedFormulaOptions))])
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return
        ( Int -> RowIndex
RowIndex Int
r
        , if RowProperties
props RowProperties -> RowProperties -> Bool
forall a. Eq a => a -> a -> Bool
== RowProperties
forall a. Default a => a
def
            then Maybe RowProperties
forall a. Maybe a
Nothing
            else RowProperties -> Maybe RowProperties
forall a. a -> Maybe a
Just RowProperties
props
        , [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
cells)

    -- NB: According to format specification default value for cells without
    -- `t` attribute is a `n` - number.
    --
    -- Schema part from spec (see the `CellValue` spec reference):
    -- <xsd:complexType name="CT_Cell">
    --  ..
    --  <xsd:attribute name="t" type="ST_CellType" use="optional" default="n"/>
    -- </xsd:complexType>
    parseCell ::
         Xeno.Node
      -> Either Text ( RowIndex
                     , ColumnIndex
                     , Cell
                     , Maybe (SharedFormulaIndex, SharedFormulaOptions))
    parseCell :: Node
-> Either
     Text
     (RowIndex, ColumnIndex, Cell,
      Maybe (SharedFormulaIndex, SharedFormulaOptions))
parseCell Node
cell = do
      (Range
ref, Maybe Int
s, ByteString
t) <-
        Node
-> AttrParser (Range, Maybe Int, ByteString)
-> Either Text (Range, Maybe Int, ByteString)
forall a. Node -> AttrParser a -> Either Text a
parseAttributes Node
cell (AttrParser (Range, Maybe Int, ByteString)
 -> Either Text (Range, Maybe Int, ByteString))
-> AttrParser (Range, Maybe Int, ByteString)
-> Either Text (Range, Maybe Int, ByteString)
forall a b. (a -> b) -> a -> b
$
        (,,) (Range
 -> Maybe Int -> ByteString -> (Range, Maybe Int, ByteString))
-> AttrParser Range
-> AttrParser
     (Maybe Int -> ByteString -> (Range, Maybe Int, ByteString))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> AttrParser Range
forall a. FromAttrBs a => ByteString -> AttrParser a
fromAttr ByteString
"r" AttrParser
  (Maybe Int -> ByteString -> (Range, Maybe Int, ByteString))
-> AttrParser (Maybe Int)
-> AttrParser (ByteString -> (Range, Maybe Int, ByteString))
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> AttrParser (Maybe Int)
forall a. FromAttrBs a => ByteString -> AttrParser (Maybe a)
maybeAttr ByteString
"s" AttrParser (ByteString -> (Range, Maybe Int, ByteString))
-> AttrParser ByteString
-> AttrParser (Range, Maybe Int, ByteString)
forall a b. AttrParser (a -> b) -> AttrParser a -> AttrParser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> ByteString -> AttrParser ByteString
forall a. FromAttrBs a => ByteString -> a -> AttrParser a
fromAttrDef ByteString
"t" ByteString
"n"
      (Maybe Node
fNode, Maybe Node
vNode, Maybe Node
isNode) <-
        Node
-> ChildCollector (Maybe Node, Maybe Node, Maybe Node)
-> Either Text (Maybe Node, Maybe Node, Maybe Node)
forall a. Node -> ChildCollector a -> Either Text a
collectChildren Node
cell (ChildCollector (Maybe Node, Maybe Node, Maybe Node)
 -> Either Text (Maybe Node, Maybe Node, Maybe Node))
-> ChildCollector (Maybe Node, Maybe Node, Maybe Node)
-> Either Text (Maybe Node, Maybe Node, Maybe Node)
forall a b. (a -> b) -> a -> b
$
        (,,) (Maybe Node
 -> Maybe Node
 -> Maybe Node
 -> (Maybe Node, Maybe Node, Maybe Node))
-> ChildCollector (Maybe Node)
-> ChildCollector
     (Maybe Node -> Maybe Node -> (Maybe Node, Maybe Node, Maybe Node))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> ChildCollector (Maybe Node)
maybeChild ByteString
"f" ChildCollector
  (Maybe Node -> Maybe Node -> (Maybe Node, Maybe Node, Maybe Node))
-> ChildCollector (Maybe Node)
-> ChildCollector
     (Maybe Node -> (Maybe Node, Maybe Node, Maybe Node))
forall a b.
ChildCollector (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> ChildCollector (Maybe Node)
maybeChild ByteString
"v" ChildCollector (Maybe Node -> (Maybe Node, Maybe Node, Maybe Node))
-> ChildCollector (Maybe Node)
-> ChildCollector (Maybe Node, Maybe Node, Maybe Node)
forall a b.
ChildCollector (a -> b) -> ChildCollector a -> ChildCollector b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ByteString -> ChildCollector (Maybe Node)
maybeChild ByteString
"is"
      let vConverted :: (FromAttrBs a) => Either Text (Maybe a)
          vConverted :: forall a. FromAttrBs a => Either Text (Maybe a)
vConverted =
            case Node -> ByteString
contentBs (Node -> ByteString) -> Maybe Node -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Node
vNode of
              Maybe ByteString
Nothing -> Maybe a -> Either Text (Maybe a)
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
              Just ByteString
c -> a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> Either Text a -> Either Text (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Either Text a
forall a. FromAttrBs a => ByteString -> Either Text a
fromAttrBs ByteString
c
      Maybe FormulaData
mFormulaData <- (Node -> Either Text FormulaData)
-> Maybe Node -> Either Text (Maybe FormulaData)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Maybe a -> m (Maybe b)
mapM Node -> Either Text FormulaData
forall a. FromXenoNode a => Node -> Either Text a
fromXenoNode Maybe Node
fNode
      Maybe CellValue
d <-
        case ByteString
t of
          (ByteString
"s" :: ByteString) -> do
            Maybe Int
si <- Either Text (Maybe Int)
forall a. FromAttrBs a => Either Text (Maybe a)
vConverted
            case SharedStringTable -> Int -> Maybe XlsxText
sstItem SharedStringTable
sst (Int -> Maybe XlsxText) -> Maybe Int -> Maybe XlsxText
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Int
si of
              Just XlsxText
xlTxt -> Maybe CellValue -> Either Text (Maybe CellValue)
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe CellValue -> Either Text (Maybe CellValue))
-> Maybe CellValue -> Either Text (Maybe CellValue)
forall a b. (a -> b) -> a -> b
$ CellValue -> Maybe CellValue
forall a. a -> Maybe a
Just (XlsxText -> CellValue
xlsxTextToCellValue XlsxText
xlTxt)
              Maybe XlsxText
Nothing -> Text -> Either Text (Maybe CellValue)
forall a. Text -> Either Text a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError Text
"bad shared string index"
          ByteString
"inlineStr" -> (Node -> Either Text CellValue)
-> Maybe Node -> Either Text (Maybe CellValue)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Maybe a -> m (Maybe b)
mapM ((XlsxText -> CellValue)
-> Either Text XlsxText -> Either Text CellValue
forall a b. (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap XlsxText -> CellValue
xlsxTextToCellValue (Either Text XlsxText -> Either Text CellValue)
-> (Node -> Either Text XlsxText) -> Node -> Either Text CellValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Node -> Either Text XlsxText
forall a. FromXenoNode a => Node -> Either Text a
fromXenoNode) Maybe Node
isNode
          ByteString
"str" -> (Text -> CellValue) -> Maybe Text -> Maybe CellValue
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> CellValue
CellText (Maybe Text -> Maybe CellValue)
-> Either Text (Maybe Text) -> Either Text (Maybe CellValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either Text (Maybe Text)
forall a. FromAttrBs a => Either Text (Maybe a)
vConverted
          ByteString
"n" -> (Double -> CellValue) -> Maybe Double -> Maybe CellValue
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Double -> CellValue
CellDouble (Maybe Double -> Maybe CellValue)
-> Either Text (Maybe Double) -> Either Text (Maybe CellValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either Text (Maybe Double)
forall a. FromAttrBs a => Either Text (Maybe a)
vConverted
          ByteString
"b" -> (Bool -> CellValue) -> Maybe Bool -> Maybe CellValue
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> CellValue
CellBool (Maybe Bool -> Maybe CellValue)
-> Either Text (Maybe Bool) -> Either Text (Maybe CellValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either Text (Maybe Bool)
forall a. FromAttrBs a => Either Text (Maybe a)
vConverted
          ByteString
"e" -> (ErrorType -> CellValue) -> Maybe ErrorType -> Maybe CellValue
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ErrorType -> CellValue
CellError (Maybe ErrorType -> Maybe CellValue)
-> Either Text (Maybe ErrorType) -> Either Text (Maybe CellValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Either Text (Maybe ErrorType)
forall a. FromAttrBs a => Either Text (Maybe a)
vConverted
          ByteString
unexpected ->
            Text -> Either Text (Maybe CellValue)
forall a. Text -> Either Text a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (Text -> Either Text (Maybe CellValue))
-> Text -> Either Text (Maybe CellValue)
forall a b. (a -> b) -> a -> b
$ Text
"unexpected cell type " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
unexpected)
      let (RowIndex
r, ColumnIndex
c) = Range -> (RowIndex, ColumnIndex)
fromSingleCellRefNoting Range
ref
          f :: Maybe CellFormula
f = FormulaData -> CellFormula
frmdFormula (FormulaData -> CellFormula)
-> Maybe FormulaData -> Maybe CellFormula
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe FormulaData
mFormulaData
          shared :: Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared = FormulaData -> Maybe (SharedFormulaIndex, SharedFormulaOptions)
frmdShared (FormulaData -> Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Maybe FormulaData
-> Maybe (SharedFormulaIndex, SharedFormulaOptions)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe FormulaData
mFormulaData
      (RowIndex, ColumnIndex, Cell,
 Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Either
     Text
     (RowIndex, ColumnIndex, Cell,
      Maybe (SharedFormulaIndex, SharedFormulaOptions))
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return (RowIndex
r, ColumnIndex
c, Maybe Int
-> Maybe CellValue -> Maybe Comment -> Maybe CellFormula -> Cell
Cell Maybe Int
s Maybe CellValue
d Maybe Comment
forall a. Maybe a
Nothing Maybe CellFormula
f, Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared)

extractSheet ::
     Zip.Archive
  -> SharedStringTable
  -> ContentTypes
  -> Caches
  -> WorksheetFile
  -> Parser Worksheet
extractSheet :: Archive
-> SharedStringTable
-> ContentTypes
-> Caches
-> WorksheetFile
-> Parser Worksheet
extractSheet Archive
ar SharedStringTable
sst ContentTypes
contentTypes Caches
caches WorksheetFile
wf = do
  let filePath :: [Char]
filePath = WorksheetFile -> [Char]
wfPath WorksheetFile
wf
  ByteString
file <- ParseError -> Maybe ByteString -> Either ParseError ByteString
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
filePath) (Maybe ByteString -> Either ParseError ByteString)
-> Maybe ByteString -> Either ParseError ByteString
forall a b. (a -> b) -> a -> b
$ Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
filePath Archive
ar
  Cursor
cur <- (Document -> Cursor)
-> Either ParseError Document -> Either ParseError Cursor
forall a b. (a -> b) -> Either ParseError a -> Either ParseError b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Document -> Cursor
fromDocument (Either ParseError Document -> Either ParseError Cursor)
-> (Either SomeException Document -> Either ParseError Document)
-> Either SomeException Document
-> Either ParseError Cursor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SomeException -> ParseError)
-> Either SomeException Document -> Either ParseError Document
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\SomeException
ex -> [Char] -> Text -> ParseError
InvalidFile [Char]
filePath ([Char] -> Text
T.pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ SomeException -> [Char]
forall a. Show a => a -> [Char]
show SomeException
ex)) (Either SomeException Document -> Either ParseError Cursor)
-> Either SomeException Document -> Either ParseError Cursor
forall a b. (a -> b) -> a -> b
$
         ParseSettings -> ByteString -> Either SomeException Document
parseLBS ParseSettings
forall a. Default a => a
def ByteString
file
  Relationships
sheetRels <- Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
filePath

  -- The specification says the file should contain either 0 or 1 @sheetViews@
  -- (4th edition, section 18.3.1.88, p. 1704 and definition CT_Worksheet, p. 3910)
  let  sheetViewList :: [a]
sheetViewList = Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"sheetViews") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"sheetView") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor
       sheetViews :: Maybe [a]
sheetViews = case [a]
forall {a}. FromCursor a => [a]
sheetViewList of
         []    -> Maybe [a]
forall a. Maybe a
Nothing
         [a]
views -> [a] -> Maybe [a]
forall a. a -> Maybe a
Just [a]
views

  let commentsType :: a
commentsType = a
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
      commentTarget :: Maybe FilePath
      commentTarget :: Maybe [Char]
commentTarget = ShowS
logicalNameToZipItemName ShowS -> (Relationship -> [Char]) -> Relationship -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relationship -> [Char]
relTarget (Relationship -> [Char]) -> Maybe Relationship -> Maybe [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Relationships -> Maybe Relationship
findRelByType Text
forall {a}. IsString a => a
commentsType Relationships
sheetRels
      legacyDrRId :: [a]
legacyDrRId = Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"legacyDrawing") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Name -> Cursor -> [a]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute (Text -> Name
odrText
"id")
      legacyDrPath :: Maybe [Char]
legacyDrPath = (Relationship -> [Char]) -> Maybe Relationship -> Maybe [Char]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ShowS
logicalNameToZipItemName ShowS -> (Relationship -> [Char]) -> Relationship -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relationship -> [Char]
relTarget) (Maybe Relationship -> Maybe [Char])
-> (RefId -> Maybe Relationship) -> RefId -> Maybe [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RefId -> Relationships -> Maybe Relationship)
-> Relationships -> RefId -> Maybe Relationship
forall a b c. (a -> b -> c) -> b -> a -> c
flip RefId -> Relationships -> Maybe Relationship
Relationships.lookup Relationships
sheetRels  (RefId -> Maybe [Char]) -> Maybe RefId -> Maybe [Char]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [RefId] -> Maybe RefId
forall a. [a] -> Maybe a
listToMaybe [RefId]
forall {a}. FromAttrVal a => [a]
legacyDrRId

  Maybe CommentTable
commentsMap :: Maybe CommentTable <- Either ParseError (Maybe CommentTable)
-> ([Char] -> Either ParseError (Maybe CommentTable))
-> Maybe [Char]
-> Either ParseError (Maybe CommentTable)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe CommentTable -> Either ParseError (Maybe CommentTable)
forall a b. b -> Either a b
Right Maybe CommentTable
forall a. Maybe a
Nothing) (Archive
-> Maybe [Char] -> [Char] -> Either ParseError (Maybe CommentTable)
getComments Archive
ar Maybe [Char]
legacyDrPath) Maybe [Char]
commentTarget

  -- Likewise, @pageSetup@ also occurs either 0 or 1 times
  let pageSetup :: Maybe a
pageSetup = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"pageSetup") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor

      cws :: [a]
cws = Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"cols") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"col") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor

      (Map RowIndex RowProperties
rowProps, CellMap
cells0, Map SharedFormulaIndex SharedFormulaOptions
sharedFormulas) =
        [(RowIndex, Maybe RowProperties,
  [(RowIndex, ColumnIndex, Cell,
    Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
forall {t :: * -> *}.
Foldable t =>
t (RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collect ([(RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions))
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor
-> (Cursor
    -> [(RowIndex, Maybe RowProperties,
         [(RowIndex, ColumnIndex, Cell,
           Maybe (SharedFormulaIndex, SharedFormulaOptions))])])
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"sheetData") Axis
-> (Cursor
    -> [(RowIndex, Maybe RowProperties,
         [(RowIndex, ColumnIndex, Cell,
           Maybe (SharedFormulaIndex, SharedFormulaOptions))])])
-> Cursor
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"row") Axis
-> (Cursor
    -> [(RowIndex, Maybe RowProperties,
         [(RowIndex, ColumnIndex, Cell,
           Maybe (SharedFormulaIndex, SharedFormulaOptions))])])
-> Cursor
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
parseRow
      parseRow ::
           Cursor
        -> [( RowIndex
            , Maybe RowProperties
            , [(RowIndex, ColumnIndex, Cell, Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
      parseRow :: Cursor
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
parseRow Cursor
c = do
        RowIndex
r <- Int -> RowIndex
RowIndex (Int -> RowIndex) -> [Int] -> [RowIndex]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> Cursor -> [Int]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"r" Cursor
c
        let prop :: RowProperties
prop = RowProps
              { rowHeight :: Maybe RowHeight
rowHeight = do Double
h <- [Double] -> Maybe Double
forall a. [a] -> Maybe a
listToMaybe ([Double] -> Maybe Double) -> [Double] -> Maybe Double
forall a b. (a -> b) -> a -> b
$ Name -> Cursor -> [Double]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"ht" Cursor
c
                               case Name -> Cursor -> [Bool]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"customHeight" Cursor
c of
                                 [Bool
True] -> RowHeight -> Maybe RowHeight
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (RowHeight -> Maybe RowHeight) -> RowHeight -> Maybe RowHeight
forall a b. (a -> b) -> a -> b
$ Double -> RowHeight
CustomHeight    Double
h
                                 [Bool]
_      -> RowHeight -> Maybe RowHeight
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (RowHeight -> Maybe RowHeight) -> RowHeight -> Maybe RowHeight
forall a b. (a -> b) -> a -> b
$ Double -> RowHeight
AutomaticHeight Double
h
              , rowStyle :: Maybe Int
rowStyle  = [Int] -> Maybe Int
forall a. [a] -> Maybe a
listToMaybe ([Int] -> Maybe Int) -> [Int] -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Name -> Cursor -> [Int]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"s" Cursor
c
              , rowHidden :: Bool
rowHidden =
                  case Name -> Cursor -> [Bool]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"hidden" Cursor
c of
                    []  -> Bool
False
                    Bool
f:[Bool]
_ -> Bool
f
              }
        (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> [(RowIndex, Maybe RowProperties,
     [(RowIndex, ColumnIndex, Cell,
       Maybe (SharedFormulaIndex, SharedFormulaOptions))])]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ( RowIndex
r
               , if RowProperties
prop RowProperties -> RowProperties -> Bool
forall a. Eq a => a -> a -> Bool
== RowProperties
forall a. Default a => a
def then Maybe RowProperties
forall a. Maybe a
Nothing else RowProperties -> Maybe RowProperties
forall a. a -> Maybe a
Just RowProperties
prop
               , Cursor
c Cursor
-> (Cursor
    -> [(RowIndex, ColumnIndex, Cell,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"c") Axis
-> (Cursor
    -> [(RowIndex, ColumnIndex, Cell,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> Cursor
-> [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor
-> [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
parseCell
               )
      parseCell ::
           Cursor
        -> [(RowIndex, ColumnIndex, Cell, Maybe (SharedFormulaIndex, SharedFormulaOptions))]
      parseCell :: Cursor
-> [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
parseCell Cursor
cell = do
        Range
ref <- Name -> Cursor -> [Range]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"r" Cursor
cell
        let s :: Maybe a
s = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Cursor
cell Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> a) -> a
$| Name -> Cursor -> [Text]
attribute Name
"s" (Cursor -> [Text]) -> (Text -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> [a]
forall (m :: * -> *) a. (MonadFail m, Integral a) => Text -> m a
decimal
            -- NB: According to format specification default value for cells without
            -- `t` attribute is a `n` - number.
            --
            -- <xsd:complexType name="CT_Cell" from spec (see the `CellValue` spec reference)>
            --  ..
            --  <xsd:attribute name="t" type="ST_CellType" use="optional" default="n"/>
            -- </xsd:complexType>
            t :: Text
t = Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"n" (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ [Text] -> Maybe Text
forall a. [a] -> Maybe a
listToMaybe ([Text] -> Maybe Text) -> [Text] -> Maybe Text
forall a b. (a -> b) -> a -> b
$ Cursor
cell Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> a) -> a
$| Name -> Cursor -> [Text]
attribute Name
"t"
            d :: Maybe CellValue
d = [CellValue] -> Maybe CellValue
forall a. [a] -> Maybe a
listToMaybe ([CellValue] -> Maybe CellValue) -> [CellValue] -> Maybe CellValue
forall a b. (a -> b) -> a -> b
$ SharedStringTable -> Text -> Cursor -> [CellValue]
extractCellValue SharedStringTable
sst Text
t Cursor
cell
            mFormulaData :: Maybe
  (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
mFormulaData = [(CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))]
-> Maybe
     (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
forall a. [a] -> Maybe a
listToMaybe ([(CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))]
 -> Maybe
      (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions)))
-> [(CellFormula,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
-> Maybe
     (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
forall a b. (a -> b) -> a -> b
$ Cursor
cell Cursor
-> (Cursor
    -> [(CellFormula,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> [(CellFormula,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"f") Axis
-> (Cursor
    -> [(CellFormula,
         Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> Cursor
-> [(CellFormula,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor
-> [(CellFormula,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
formulaDataFromCursor
            f :: Maybe CellFormula
f = (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> CellFormula
forall a b. (a, b) -> a
fst ((CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
 -> CellFormula)
-> Maybe
     (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Maybe CellFormula
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe
  (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
mFormulaData
            shared :: Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared = (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Maybe (SharedFormulaIndex, SharedFormulaOptions)
forall a b. (a, b) -> b
snd ((CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
 -> Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Maybe
     (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> Maybe (SharedFormulaIndex, SharedFormulaOptions)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe
  (CellFormula, Maybe (SharedFormulaIndex, SharedFormulaOptions))
mFormulaData
            (RowIndex
r, ColumnIndex
c) = Range -> (RowIndex, ColumnIndex)
fromSingleCellRefNoting Range
ref
            comment :: Maybe Comment
comment = Maybe CommentTable
commentsMap Maybe CommentTable
-> (CommentTable -> Maybe Comment) -> Maybe Comment
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Range -> CommentTable -> Maybe Comment
lookupComment Range
ref
        (RowIndex, ColumnIndex, Cell,
 Maybe (SharedFormulaIndex, SharedFormulaOptions))
-> [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (RowIndex
r, ColumnIndex
c, Maybe Int
-> Maybe CellValue -> Maybe Comment -> Maybe CellFormula -> Cell
Cell Maybe Int
forall {a}. Integral a => Maybe a
s Maybe CellValue
d Maybe Comment
comment Maybe CellFormula
f, Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared)
      collect :: t (RowIndex, Maybe RowProperties,
   [(RowIndex, ColumnIndex, Cell,
     Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collect = ((RowIndex, Maybe RowProperties,
  [(RowIndex, ColumnIndex, Cell,
    Maybe (SharedFormulaIndex, SharedFormulaOptions))])
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions)
 -> (Map RowIndex RowProperties, CellMap,
     Map SharedFormulaIndex SharedFormulaOptions))
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> t (RowIndex, Maybe RowProperties,
      [(RowIndex, ColumnIndex, Cell,
        Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRow (Map RowIndex RowProperties
forall k a. Map k a
M.empty, CellMap
forall k a. Map k a
M.empty, Map SharedFormulaIndex SharedFormulaOptions
forall k a. Map k a
M.empty)
      collectRow ::
           ( RowIndex
           , Maybe RowProperties
           , [(RowIndex, ColumnIndex, Cell, Maybe (SharedFormulaIndex, SharedFormulaOptions))])
        -> (Map RowIndex RowProperties, CellMap, Map SharedFormulaIndex SharedFormulaOptions)
        -> (Map RowIndex RowProperties, CellMap, Map SharedFormulaIndex SharedFormulaOptions)
      collectRow :: (RowIndex, Maybe RowProperties,
 [(RowIndex, ColumnIndex, Cell,
   Maybe (SharedFormulaIndex, SharedFormulaOptions))])
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
-> (Map RowIndex RowProperties, CellMap,
    Map SharedFormulaIndex SharedFormulaOptions)
collectRow (RowIndex
r, Maybe RowProperties
mRP, [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
rowCells) (Map RowIndex RowProperties
rowMap, CellMap
cellMap, Map SharedFormulaIndex SharedFormulaOptions
sharedF) =
        let ([((RowIndex, ColumnIndex), Cell)]
newCells0, [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
newSharedF0) =
              [(((RowIndex, ColumnIndex), Cell),
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
-> ([((RowIndex, ColumnIndex), Cell)],
    [Maybe (SharedFormulaIndex, SharedFormulaOptions)])
forall a b. [(a, b)] -> ([a], [b])
unzip [(((RowIndex
x,ColumnIndex
y),Cell
cd), Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared) | (RowIndex
x, ColumnIndex
y, Cell
cd, Maybe (SharedFormulaIndex, SharedFormulaOptions)
shared) <- [(RowIndex, ColumnIndex, Cell,
  Maybe (SharedFormulaIndex, SharedFormulaOptions))]
rowCells]
            newCells :: CellMap
newCells = [((RowIndex, ColumnIndex), Cell)] -> CellMap
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [((RowIndex, ColumnIndex), Cell)]
newCells0
            newSharedF :: Map SharedFormulaIndex SharedFormulaOptions
newSharedF = [(SharedFormulaIndex, SharedFormulaOptions)]
-> Map SharedFormulaIndex SharedFormulaOptions
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SharedFormulaIndex, SharedFormulaOptions)]
 -> Map SharedFormulaIndex SharedFormulaOptions)
-> [(SharedFormulaIndex, SharedFormulaOptions)]
-> Map SharedFormulaIndex SharedFormulaOptions
forall a b. (a -> b) -> a -> b
$ [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
-> [(SharedFormulaIndex, SharedFormulaOptions)]
forall a. [Maybe a] -> [a]
catMaybes [Maybe (SharedFormulaIndex, SharedFormulaOptions)]
newSharedF0
            newRowMap :: Map RowIndex RowProperties
newRowMap = case Maybe RowProperties
mRP of
              Just RowProperties
rp -> RowIndex
-> RowProperties
-> Map RowIndex RowProperties
-> Map RowIndex RowProperties
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert RowIndex
r RowProperties
rp Map RowIndex RowProperties
rowMap
              Maybe RowProperties
Nothing -> Map RowIndex RowProperties
rowMap
        in (Map RowIndex RowProperties
newRowMap, CellMap
cellMap CellMap -> CellMap -> CellMap
forall a. Semigroup a => a -> a -> a
<> CellMap
newCells, Map SharedFormulaIndex SharedFormulaOptions
sharedF Map SharedFormulaIndex SharedFormulaOptions
-> Map SharedFormulaIndex SharedFormulaOptions
-> Map SharedFormulaIndex SharedFormulaOptions
forall a. Semigroup a => a -> a -> a
<> Map SharedFormulaIndex SharedFormulaOptions
newSharedF)

      commentCells :: CellMap
commentCells =
        [((RowIndex, ColumnIndex), Cell)] -> CellMap
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
          [ (Range -> (RowIndex, ColumnIndex)
fromSingleCellRefNoting Range
r, Cell
forall a. Default a => a
def {_cellComment = Just cmnt})
          | (Range
r, Comment
cmnt) <- [(Range, Comment)]
-> (CommentTable -> [(Range, Comment)])
-> Maybe CommentTable
-> [(Range, Comment)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] CommentTable -> [(Range, Comment)]
CommentTable.toList Maybe CommentTable
commentsMap
          ]
      cells :: CellMap
cells = CellMap
cells0 CellMap -> CellMap -> CellMap
forall k a. Ord k => Map k a -> Map k a -> Map k a
`M.union` CellMap
commentCells

      mProtection :: Maybe a
mProtection = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"sheetProtection") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor

      mDrawingId :: Maybe a
mDrawingId = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"drawing") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Name -> Cursor -> [a]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute (Text -> Name
odrText
"id")

      merges :: [Range]
merges = Cursor
cur Cursor -> (Cursor -> [Range]) -> [Range]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Cursor -> [Range]
parseMerges
      parseMerges :: Cursor -> [Range]
      parseMerges :: Cursor -> [Range]
parseMerges = Name -> Axis
element (Text -> Name
n_ Text
"mergeCells") Axis -> (Cursor -> [Range]) -> Cursor -> [Range]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"mergeCell") Axis -> (Cursor -> [Range]) -> Cursor -> [Range]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Name -> Cursor -> [Range]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"ref"

      condFormtattings :: Map SqRef ConditionalFormatting
condFormtattings = [(SqRef, ConditionalFormatting)] -> Map SqRef ConditionalFormatting
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SqRef, ConditionalFormatting)]
 -> Map SqRef ConditionalFormatting)
-> ([CfPair] -> [(SqRef, ConditionalFormatting)])
-> [CfPair]
-> Map SqRef ConditionalFormatting
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CfPair -> (SqRef, ConditionalFormatting))
-> [CfPair] -> [(SqRef, ConditionalFormatting)]
forall a b. (a -> b) -> [a] -> [b]
map CfPair -> (SqRef, ConditionalFormatting)
unCfPair  ([CfPair] -> Map SqRef ConditionalFormatting)
-> [CfPair] -> Map SqRef ConditionalFormatting
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor -> (Cursor -> [CfPair]) -> [CfPair]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"conditionalFormatting") Axis -> (Cursor -> [CfPair]) -> Cursor -> [CfPair]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [CfPair]
forall a. FromCursor a => Cursor -> [a]
fromCursor

      validations :: Map SqRef DataValidation
validations = [(SqRef, DataValidation)] -> Map SqRef DataValidation
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(SqRef, DataValidation)] -> Map SqRef DataValidation)
-> ([DvPair] -> [(SqRef, DataValidation)])
-> [DvPair]
-> Map SqRef DataValidation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DvPair -> (SqRef, DataValidation))
-> [DvPair] -> [(SqRef, DataValidation)]
forall a b. (a -> b) -> [a] -> [b]
map DvPair -> (SqRef, DataValidation)
unDvPair ([DvPair] -> Map SqRef DataValidation)
-> [DvPair] -> Map SqRef DataValidation
forall a b. (a -> b) -> a -> b
$
          Cursor
cur Cursor -> (Cursor -> [DvPair]) -> [DvPair]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"dataValidations") Axis -> (Cursor -> [DvPair]) -> Cursor -> [DvPair]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"dataValidation") Axis -> (Cursor -> [DvPair]) -> Cursor -> [DvPair]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [DvPair]
forall a. FromCursor a => Cursor -> [a]
fromCursor

      tableIds :: [a]
tableIds =
        Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"tableParts") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"tablePart") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
        Name -> Cursor -> [a]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute (Text -> Name
odr Text
"id")

  let mAutoFilter :: Maybe a
mAutoFilter = [a] -> Maybe a
forall a. [a] -> Maybe a
listToMaybe ([a] -> Maybe a) -> [a] -> Maybe a
forall a b. (a -> b) -> a -> b
$ Cursor
cur Cursor -> (Cursor -> [a]) -> [a]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"autoFilter") Axis -> (Cursor -> [a]) -> Cursor -> [a]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor

  Maybe Drawing
mDrawing <- case Maybe RefId
forall {a}. FromAttrVal a => Maybe a
mDrawingId of
      Just RefId
dId -> do
          [Char]
fp <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
filePath Relationships
sheetRels RefId
dId
          Drawing -> Maybe Drawing
forall a. a -> Maybe a
Just (Drawing -> Maybe Drawing)
-> Either ParseError Drawing -> Either ParseError (Maybe Drawing)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Archive -> ContentTypes -> [Char] -> Either ParseError Drawing
getDrawing Archive
ar ContentTypes
contentTypes [Char]
fp
      Maybe RefId
Nothing  ->
          Maybe Drawing -> Either ParseError (Maybe Drawing)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Drawing
forall a. Maybe a
Nothing

  let ptType :: a
ptType = a
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable"
  [PivotTable]
pTables <- [Relationship]
-> (Relationship -> Either ParseError PivotTable)
-> Either ParseError [PivotTable]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (Text -> Relationships -> [Relationship]
allByType Text
forall {a}. IsString a => a
ptType Relationships
sheetRels) ((Relationship -> Either ParseError PivotTable)
 -> Either ParseError [PivotTable])
-> (Relationship -> Either ParseError PivotTable)
-> Either ParseError [PivotTable]
forall a b. (a -> b) -> a -> b
$ \Relationship
rel -> do
    let ptPath :: [Char]
ptPath = ShowS
logicalNameToZipItemName ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Relationship -> [Char]
relTarget Relationship
rel
    ByteString
bs <- ParseError -> Maybe ByteString -> Either ParseError ByteString
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
ptPath) (Maybe ByteString -> Either ParseError ByteString)
-> Maybe ByteString -> Either ParseError ByteString
forall a b. (a -> b) -> a -> b
$ Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
ptPath Archive
ar
    ParseError -> Maybe PivotTable -> Either ParseError PivotTable
forall a b. a -> Maybe b -> Either a b
note (Text -> ParseError
InconsistentXlsx (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ Text
"Bad pivot table in " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack [Char]
ptPath) (Maybe PivotTable -> Either ParseError PivotTable)
-> Maybe PivotTable -> Either ParseError PivotTable
forall a b. (a -> b) -> a -> b
$
      (CacheId -> Maybe (Text, Range, [CacheField]))
-> ByteString -> Maybe PivotTable
parsePivotTable ((CacheId -> Caches -> Maybe (Text, Range, [CacheField]))
-> Caches -> CacheId -> Maybe (Text, Range, [CacheField])
forall a b c. (a -> b -> c) -> b -> a -> c
flip CacheId -> Caches -> Maybe (Text, Range, [CacheField])
forall a b. Eq a => a -> [(a, b)] -> Maybe b
Prelude.lookup Caches
caches) ByteString
bs

  [Table]
tables <- [RefId]
-> (RefId -> Either ParseError Table) -> Either ParseError [Table]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [RefId]
forall {a}. FromAttrVal a => [a]
tableIds ((RefId -> Either ParseError Table) -> Either ParseError [Table])
-> (RefId -> Either ParseError Table) -> Either ParseError [Table]
forall a b. (a -> b) -> a -> b
$ \RefId
rId -> do
    [Char]
fp <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
filePath Relationships
sheetRels RefId
rId
    Archive -> [Char] -> Either ParseError Table
getTable Archive
ar [Char]
fp

  Worksheet -> Parser Worksheet
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Worksheet -> Parser Worksheet) -> Worksheet -> Parser Worksheet
forall a b. (a -> b) -> a -> b
$
    [ColumnsProperties]
-> Map RowIndex RowProperties
-> CellMap
-> Maybe Drawing
-> [Range]
-> Maybe [SheetView]
-> Maybe PageSetup
-> Map SqRef ConditionalFormatting
-> Map SqRef DataValidation
-> [PivotTable]
-> Maybe AutoFilter
-> [Table]
-> Maybe SheetProtection
-> Map SharedFormulaIndex SharedFormulaOptions
-> SheetState
-> Worksheet
Worksheet
      [ColumnsProperties]
forall {a}. FromCursor a => [a]
cws
      Map RowIndex RowProperties
rowProps
      CellMap
cells
      Maybe Drawing
mDrawing
      [Range]
merges
      Maybe [SheetView]
forall {a}. FromCursor a => Maybe [a]
sheetViews
      Maybe PageSetup
forall {a}. FromCursor a => Maybe a
pageSetup
      Map SqRef ConditionalFormatting
condFormtattings
      Map SqRef DataValidation
validations
      [PivotTable]
pTables
      Maybe AutoFilter
forall {a}. FromCursor a => Maybe a
mAutoFilter
      [Table]
tables
      Maybe SheetProtection
forall {a}. FromCursor a => Maybe a
mProtection
      Map SharedFormulaIndex SharedFormulaOptions
sharedFormulas
      (WorksheetFile -> SheetState
wfState WorksheetFile
wf)

extractCellValue :: SharedStringTable -> Text -> Cursor -> [CellValue]
extractCellValue :: SharedStringTable -> Text -> Cursor -> [CellValue]
extractCellValue SharedStringTable
sst Text
t Cursor
cur
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"s" = do
    Int
si <- [Char] -> [Int]
forall {b}. FromAttrVal b => [Char] -> [b]
vConverted [Char]
"shared string"
    case SharedStringTable -> Int -> Maybe XlsxText
sstItem SharedStringTable
sst Int
si of
      Just XlsxText
xlTxt -> CellValue -> [CellValue]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (CellValue -> [CellValue]) -> CellValue -> [CellValue]
forall a b. (a -> b) -> a -> b
$ XlsxText -> CellValue
xlsxTextToCellValue XlsxText
xlTxt
      Maybe XlsxText
Nothing -> [Char] -> [CellValue]
forall a. [Char] -> [a]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"bad shared string index"
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"inlineStr" =
    Cursor
cur Cursor -> (Cursor -> [CellValue]) -> [CellValue]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"is") Axis -> (Cursor -> [CellValue]) -> Cursor -> [CellValue]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (XlsxText -> CellValue) -> [XlsxText] -> [CellValue]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap XlsxText -> CellValue
xlsxTextToCellValue ([XlsxText] -> [CellValue])
-> (Cursor -> [XlsxText]) -> Cursor -> [CellValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> [XlsxText]
forall a. FromCursor a => Cursor -> [a]
fromCursor
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"str" = Text -> CellValue
CellText (Text -> CellValue) -> [Text] -> [CellValue]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Text]
forall {b}. FromAttrVal b => [Char] -> [b]
vConverted [Char]
"string"
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"n" = Double -> CellValue
CellDouble (Double -> CellValue) -> [Double] -> [CellValue]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Double]
forall {b}. FromAttrVal b => [Char] -> [b]
vConverted [Char]
"double"
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"b" = Bool -> CellValue
CellBool (Bool -> CellValue) -> [Bool] -> [CellValue]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [Bool]
forall {b}. FromAttrVal b => [Char] -> [b]
vConverted [Char]
"boolean"
  | Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"e" = ErrorType -> CellValue
CellError (ErrorType -> CellValue) -> [ErrorType] -> [CellValue]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> [ErrorType]
forall {b}. FromAttrVal b => [Char] -> [b]
vConverted [Char]
"error"
  | Bool
otherwise = [Char] -> [CellValue]
forall a. [Char] -> [a]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"bad cell value"
  where
    vConverted :: [Char] -> [b]
vConverted [Char]
typeStr = do
      Text
vContent <- Cursor
cur Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"v") Axis -> (Cursor -> [Text]) -> Cursor -> [Text]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \Cursor
c ->
        Text -> [Text]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> Text
T.concat ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Cursor -> [Text]
content)
      case Reader b
forall a. FromAttrVal a => Reader a
fromAttrVal Text
vContent of
        Right (b
val, Text
_) -> b -> [b]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> [b]) -> b -> [b]
forall a b. (a -> b) -> a -> b
$ b
val
        Either [Char] (b, Text)
_ -> [Char] -> [b]
forall a. [Char] -> [a]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> [b]) -> [Char] -> [b]
forall a b. (a -> b) -> a -> b
$ [Char]
"bad " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
typeStr [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" cell value"

-- | Get xml cursor from the specified file inside the zip archive.
xmlCursorOptional :: Zip.Archive -> FilePath -> Parser (Maybe Cursor)
xmlCursorOptional :: Archive -> [Char] -> Parser (Maybe Cursor)
xmlCursorOptional Archive
ar [Char]
fname =
    (Cursor -> Maybe Cursor
forall a. a -> Maybe a
Just (Cursor -> Maybe Cursor)
-> Either ParseError Cursor -> Parser (Maybe Cursor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
fname) Parser (Maybe Cursor)
-> (ParseError -> Parser (Maybe Cursor)) -> Parser (Maybe Cursor)
forall a.
Either ParseError a
-> (ParseError -> Either ParseError a) -> Either ParseError a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` ParseError -> Parser (Maybe Cursor)
forall a. ParseError -> Either ParseError (Maybe a)
missingToNothing
  where
    missingToNothing :: ParseError -> Either ParseError (Maybe a)
    missingToNothing :: forall a. ParseError -> Either ParseError (Maybe a)
missingToNothing (MissingFile [Char]
_) = Maybe a -> Either ParseError (Maybe a)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing
    missingToNothing ParseError
other           = ParseError -> Either ParseError (Maybe a)
forall a. ParseError -> Either ParseError a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError ParseError
other

-- | Get xml cursor from the given file, failing with MissingFile if not found.
xmlCursorRequired :: Zip.Archive -> FilePath -> Parser Cursor
xmlCursorRequired :: Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
fname = do
    Entry
entry <- ParseError -> Maybe Entry -> Either ParseError Entry
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
fname) (Maybe Entry -> Either ParseError Entry)
-> Maybe Entry -> Either ParseError Entry
forall a b. (a -> b) -> a -> b
$ [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
fname Archive
ar
    Document
cur <- (SomeException -> ParseError)
-> Either SomeException Document -> Either ParseError Document
forall b c d. (b -> c) -> Either b d -> Either c d
forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\SomeException
ex -> [Char] -> Text -> ParseError
InvalidFile [Char]
fname ([Char] -> Text
T.pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ SomeException -> [Char]
forall a. Show a => a -> [Char]
show SomeException
ex)) (Either SomeException Document -> Either ParseError Document)
-> Either SomeException Document -> Either ParseError Document
forall a b. (a -> b) -> a -> b
$ ParseSettings -> ByteString -> Either SomeException Document
parseLBS ParseSettings
forall a. Default a => a
def (Entry -> ByteString
Zip.fromEntry Entry
entry)
    Cursor -> Either ParseError Cursor
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cursor -> Either ParseError Cursor)
-> Cursor -> Either ParseError Cursor
forall a b. (a -> b) -> a -> b
$ Document -> Cursor
fromDocument Document
cur

fromFileCursorDef ::
     FromCursor a => Zip.Archive -> FilePath -> Text -> a -> Parser a
fromFileCursorDef :: forall a.
FromCursor a =>
Archive -> [Char] -> Text -> a -> Parser a
fromFileCursorDef Archive
x [Char]
fp Text
contentsDescr a
defVal = do
  Maybe Cursor
mCur <- Archive -> [Char] -> Parser (Maybe Cursor)
xmlCursorOptional Archive
x [Char]
fp
  case Maybe Cursor
mCur of
    Just Cursor
cur ->
      ParseError -> [a] -> Parser a
forall e a. e -> [a] -> Either e a
headErr ([Char] -> Text -> ParseError
InvalidFile [Char]
fp (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ Text
"Couldn't parse " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
contentsDescr) ([a] -> Parser a) -> [a] -> Parser a
forall a b. (a -> b) -> a -> b
$ Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor Cursor
cur
    Maybe Cursor
Nothing -> a -> Parser a
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return a
defVal

fromFileCursor :: FromCursor a => Zip.Archive -> FilePath -> Text -> Parser a
fromFileCursor :: forall a. FromCursor a => Archive -> [Char] -> Text -> Parser a
fromFileCursor Archive
x [Char]
fp Text
contentsDescr = do
  Cursor
cur <- Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
x [Char]
fp
  ParseError -> [a] -> Parser a
forall e a. e -> [a] -> Either e a
headErr ([Char] -> Text -> ParseError
InvalidFile [Char]
fp (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ Text
"Couldn't parse " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
contentsDescr) ([a] -> Parser a) -> [a] -> Parser a
forall a b. (a -> b) -> a -> b
$ Cursor -> [a]
forall a. FromCursor a => Cursor -> [a]
fromCursor Cursor
cur

-- | Get shared string table
getSharedStrings  :: Zip.Archive -> Parser SharedStringTable
getSharedStrings :: Archive -> Parser SharedStringTable
getSharedStrings Archive
x =
  Archive
-> [Char] -> Text -> SharedStringTable -> Parser SharedStringTable
forall a.
FromCursor a =>
Archive -> [Char] -> Text -> a -> Parser a
fromFileCursorDef Archive
x [Char]
"xl/sharedStrings.xml" Text
"shared strings" SharedStringTable
sstEmpty

getContentTypes :: Zip.Archive -> Parser ContentTypes
getContentTypes :: Archive -> Parser ContentTypes
getContentTypes Archive
x = Archive -> [Char] -> Text -> Parser ContentTypes
forall a. FromCursor a => Archive -> [Char] -> Text -> Parser a
fromFileCursor Archive
x [Char]
"[Content_Types].xml" Text
"content types"

getStyles :: Zip.Archive -> Styles
getStyles :: Archive -> Styles
getStyles Archive
ar = case Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
"xl/styles.xml" Archive
ar of
  Maybe ByteString
Nothing  -> ByteString -> Styles
Styles ByteString
L.empty
  Just ByteString
xml -> ByteString -> Styles
Styles ByteString
xml

getComments :: Zip.Archive -> Maybe FilePath -> FilePath -> Parser (Maybe CommentTable)
getComments :: Archive
-> Maybe [Char] -> [Char] -> Either ParseError (Maybe CommentTable)
getComments Archive
ar Maybe [Char]
drp [Char]
fp = do
    Maybe Cursor
mCurComments <- Archive -> [Char] -> Parser (Maybe Cursor)
xmlCursorOptional Archive
ar [Char]
fp
    Maybe Cursor
mCurDr <- Parser (Maybe Cursor)
-> ([Char] -> Parser (Maybe Cursor))
-> Maybe [Char]
-> Parser (Maybe Cursor)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe Cursor -> Parser (Maybe Cursor)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Cursor
forall a. Maybe a
Nothing) (Archive -> [Char] -> Parser (Maybe Cursor)
xmlCursorOptional Archive
ar) Maybe [Char]
drp
    Maybe CommentTable -> Either ParseError (Maybe CommentTable)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (([Range] -> CommentTable -> CommentTable)
-> Maybe [Range] -> Maybe CommentTable -> Maybe CommentTable
forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 [Range] -> CommentTable -> CommentTable
forall {t :: * -> *}.
Foldable t =>
t Range -> CommentTable -> CommentTable
hide (Cursor -> [Range]
hidden (Cursor -> [Range]) -> Maybe Cursor -> Maybe [Range]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Cursor
mCurDr) (Maybe CommentTable -> Maybe CommentTable)
-> (Cursor -> Maybe CommentTable) -> Cursor -> Maybe CommentTable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [CommentTable] -> Maybe CommentTable
forall a. [a] -> Maybe a
listToMaybe ([CommentTable] -> Maybe CommentTable)
-> (Cursor -> [CommentTable]) -> Cursor -> Maybe CommentTable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> [CommentTable]
forall a. FromCursor a => Cursor -> [a]
fromCursor (Cursor -> Maybe CommentTable)
-> Maybe Cursor -> Maybe CommentTable
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Cursor
mCurComments)
  where
    hide :: t Range -> CommentTable -> CommentTable
hide t Range
refs (CommentTable Map Range Comment
m) = Map Range Comment -> CommentTable
CommentTable (Map Range Comment -> CommentTable)
-> Map Range Comment -> CommentTable
forall a b. (a -> b) -> a -> b
$ (Map Range Comment -> Range -> Map Range Comment)
-> Map Range Comment -> t Range -> Map Range Comment
forall b a. (b -> a -> b) -> b -> t a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Map Range Comment -> Range -> Map Range Comment
forall {k}. Ord k => Map k Comment -> k -> Map k Comment
hideComment Map Range Comment
m t Range
refs
    hideComment :: Map k Comment -> k -> Map k Comment
hideComment Map k Comment
m k
r = (Comment -> Comment) -> k -> Map k Comment -> Map k Comment
forall k a. Ord k => (a -> a) -> k -> Map k a -> Map k a
M.adjust (\Comment
c->Comment
c{_commentVisible = False}) k
r Map k Comment
m
    v :: Text -> Name
v Text
nm = Text -> Maybe Text -> Maybe Text -> Name
Name Text
nm (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"urn:schemas-microsoft-com:vml") Maybe Text
forall a. Maybe a
Nothing
    x :: Text -> Name
x Text
nm = Text -> Maybe Text -> Maybe Text -> Name
Name Text
nm (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"urn:schemas-microsoft-com:office:excel") Maybe Text
forall a. Maybe a
Nothing
    hidden :: Cursor -> [CellRef]
    hidden :: Cursor -> [Range]
hidden Cursor
cur = Cursor
cur Cursor -> (Cursor -> [Range]) -> [Range]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ (Element -> Bool) -> Axis
forall b. Boolean b => (Element -> b) -> Axis
checkElement Element -> Bool
visibleShape Axis -> (Cursor -> [Range]) -> Cursor -> [Range]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/
                 Name -> Axis
element (Text -> Name
xText
"ClientData") Axis -> (Cursor -> [Range]) -> Cursor -> [Range]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Cursor -> [Range]
shapeCellRef
    visibleShape :: Element -> Bool
visibleShape Element{[Node]
Map Name Text
Name
elementName :: Name
elementAttributes :: Map Name Text
elementNodes :: [Node]
elementName :: Element -> Name
elementAttributes :: Element -> Map Name Text
elementNodes :: Element -> [Node]
..} = Name
elementName Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
==  (Text -> Name
vText
"shape") Bool -> Bool -> Bool
&&
        Bool -> (Text -> Bool) -> Maybe Text -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Text -> Bool) -> [Text] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Text
"visibility:hidden"Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
==) ([Text] -> Bool) -> (Text -> [Text]) -> Text -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> [Text]
T.split (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
';')) (Name -> Map Name Text -> Maybe Text
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Name
"style" Map Name Text
elementAttributes)
    shapeCellRef :: Cursor -> [CellRef]
    shapeCellRef :: Cursor -> [Range]
shapeCellRef Cursor
c = do
        RowIndex
r0 <- Cursor
c Cursor -> (Cursor -> [RowIndex]) -> [RowIndex]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
xText
"Row") Axis -> (Cursor -> [RowIndex]) -> Cursor -> [RowIndex]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Text]
content (Cursor -> [Text]) -> (Text -> [RowIndex]) -> Cursor -> [RowIndex]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> [RowIndex]
forall (m :: * -> *) a. (MonadFail m, Integral a) => Text -> m a
decimal
        ColumnIndex
c0 <- Cursor
c Cursor -> (Cursor -> [ColumnIndex]) -> [ColumnIndex]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
xText
"Column") Axis -> (Cursor -> [ColumnIndex]) -> Cursor -> [ColumnIndex]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Cursor -> [Text]
content (Cursor -> [Text])
-> (Text -> [ColumnIndex]) -> Cursor -> [ColumnIndex]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> [ColumnIndex]
forall (m :: * -> *) a. (MonadFail m, Integral a) => Text -> m a
decimal
        Range -> [Range]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (Range -> [Range]) -> Range -> [Range]
forall a b. (a -> b) -> a -> b
$ (RowIndex, ColumnIndex) -> Range
singleCellRef (RowIndex
r0 RowIndex -> RowIndex -> RowIndex
forall a. Num a => a -> a -> a
+ RowIndex
1, ColumnIndex
c0 ColumnIndex -> ColumnIndex -> ColumnIndex
forall a. Num a => a -> a -> a
+ ColumnIndex
1)

getCustomProperties :: Zip.Archive -> Parser CustomProperties
getCustomProperties :: Archive -> Parser CustomProperties
getCustomProperties Archive
ar =
  Archive
-> [Char] -> Text -> CustomProperties -> Parser CustomProperties
forall a.
FromCursor a =>
Archive -> [Char] -> Text -> a -> Parser a
fromFileCursorDef Archive
ar [Char]
"docProps/custom.xml" Text
"custom properties" CustomProperties
CustomProperties.empty

getDrawing :: Zip.Archive -> ContentTypes ->  FilePath -> Parser Drawing
getDrawing :: Archive -> ContentTypes -> [Char] -> Either ParseError Drawing
getDrawing Archive
ar ContentTypes
contentTypes [Char]
fp = do
    Cursor
cur <- Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
fp
    Relationships
drawingRels <- Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
fp
    GenericDrawing RefId RefId
unresolved <- ParseError
-> [GenericDrawing RefId RefId]
-> Either ParseError (GenericDrawing RefId RefId)
forall e a. e -> [a] -> Either e a
headErr ([Char] -> Text -> ParseError
InvalidFile [Char]
fp Text
"Couldn't parse drawing") (Cursor -> [GenericDrawing RefId RefId]
forall a. FromCursor a => Cursor -> [a]
fromCursor Cursor
cur)
    [Anchor FileInfo ChartSpace]
anchors <- [Anchor RefId RefId]
-> (Anchor RefId RefId
    -> Either ParseError (Anchor FileInfo ChartSpace))
-> Either ParseError [Anchor FileInfo ChartSpace]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (GenericDrawing RefId RefId
unresolved GenericDrawing RefId RefId
-> Getting
     [Anchor RefId RefId]
     (GenericDrawing RefId RefId)
     [Anchor RefId RefId]
-> [Anchor RefId RefId]
forall s a. s -> Getting a s a -> a
^. Getting
  [Anchor RefId RefId]
  (GenericDrawing RefId RefId)
  [Anchor RefId RefId]
forall p1 g1 p2 g2 (p3 :: * -> * -> *) (f :: * -> *).
(Profunctor p3, Functor f) =>
p3 [Anchor p1 g1] (f [Anchor p2 g2])
-> p3 (GenericDrawing p1 g1) (f (GenericDrawing p2 g2))
xdrAnchors) ((Anchor RefId RefId
  -> Either ParseError (Anchor FileInfo ChartSpace))
 -> Either ParseError [Anchor FileInfo ChartSpace])
-> (Anchor RefId RefId
    -> Either ParseError (Anchor FileInfo ChartSpace))
-> Either ParseError [Anchor FileInfo ChartSpace]
forall a b. (a -> b) -> a -> b
$ Relationships
-> Anchor RefId RefId
-> Either ParseError (Anchor FileInfo ChartSpace)
resolveFileInfo Relationships
drawingRels
    Drawing -> Either ParseError Drawing
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Drawing -> Either ParseError Drawing)
-> Drawing -> Either ParseError Drawing
forall a b. (a -> b) -> a -> b
$ [Anchor FileInfo ChartSpace] -> Drawing
forall p g. [Anchor p g] -> GenericDrawing p g
Drawing [Anchor FileInfo ChartSpace]
anchors
  where
    resolveFileInfo :: Relationships -> Anchor RefId RefId -> Parser (Anchor FileInfo ChartSpace)
    resolveFileInfo :: Relationships
-> Anchor RefId RefId
-> Either ParseError (Anchor FileInfo ChartSpace)
resolveFileInfo Relationships
rels Anchor RefId RefId
uAnch =
      case Anchor RefId RefId
uAnch Anchor RefId RefId
-> Getting
     (DrawingObject RefId RefId)
     (Anchor RefId RefId)
     (DrawingObject RefId RefId)
-> DrawingObject RefId RefId
forall s a. s -> Getting a s a -> a
^. Getting
  (DrawingObject RefId RefId)
  (Anchor RefId RefId)
  (DrawingObject RefId RefId)
forall p1 g1 p2 g2 (f :: * -> *).
Functor f =>
(DrawingObject p1 g1 -> f (DrawingObject p2 g2))
-> Anchor p1 g1 -> f (Anchor p2 g2)
anchObject of
        Picture {Bool
Maybe Text
ShapeProperties
BlipFillProperties RefId
PicNonVisual
_picMacro :: Maybe Text
_picPublished :: Bool
_picNonVisual :: PicNonVisual
_picBlipFill :: BlipFillProperties RefId
_picShapeProperties :: ShapeProperties
_picMacro :: forall p g. DrawingObject p g -> Maybe Text
_picPublished :: forall p g. DrawingObject p g -> Bool
_picNonVisual :: forall p g. DrawingObject p g -> PicNonVisual
_picBlipFill :: forall p g. DrawingObject p g -> BlipFillProperties p
_picShapeProperties :: forall p g. DrawingObject p g -> ShapeProperties
..} -> do
          let mRefId :: Maybe RefId
mRefId = BlipFillProperties RefId
_picBlipFill BlipFillProperties RefId
-> Getting (Maybe RefId) (BlipFillProperties RefId) (Maybe RefId)
-> Maybe RefId
forall s a. s -> Getting a s a -> a
^. Getting (Maybe RefId) (BlipFillProperties RefId) (Maybe RefId)
forall a1 a2 (f :: * -> *).
Functor f =>
(Maybe a1 -> f (Maybe a2))
-> BlipFillProperties a1 -> f (BlipFillProperties a2)
bfpImageInfo
          Maybe FileInfo
mFI <- Relationships -> Maybe RefId -> Either ParseError (Maybe FileInfo)
lookupFI Relationships
rels Maybe RefId
mRefId
          let pic' :: DrawingObject FileInfo g
pic' =
                Picture
                { _picMacro :: Maybe Text
_picMacro = Maybe Text
_picMacro
                , _picPublished :: Bool
_picPublished = Bool
_picPublished
                , _picNonVisual :: PicNonVisual
_picNonVisual = PicNonVisual
_picNonVisual
                , _picBlipFill :: BlipFillProperties FileInfo
_picBlipFill = (BlipFillProperties RefId
_picBlipFill BlipFillProperties RefId
-> (BlipFillProperties RefId -> BlipFillProperties FileInfo)
-> BlipFillProperties FileInfo
forall a b. a -> (a -> b) -> b
& (Maybe RefId -> Identity (Maybe FileInfo))
-> BlipFillProperties RefId
-> Identity (BlipFillProperties FileInfo)
forall a1 a2 (f :: * -> *).
Functor f =>
(Maybe a1 -> f (Maybe a2))
-> BlipFillProperties a1 -> f (BlipFillProperties a2)
bfpImageInfo ((Maybe RefId -> Identity (Maybe FileInfo))
 -> BlipFillProperties RefId
 -> Identity (BlipFillProperties FileInfo))
-> Maybe FileInfo
-> BlipFillProperties RefId
-> BlipFillProperties FileInfo
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe FileInfo
mFI)
                , _picShapeProperties :: ShapeProperties
_picShapeProperties = ShapeProperties
_picShapeProperties
                }
          Anchor FileInfo ChartSpace
-> Either ParseError (Anchor FileInfo ChartSpace)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Anchor RefId RefId
uAnch {_anchObject = pic'}
        Graphic GraphNonVisual
nv RefId
rId Transform2D
tr -> do
          [Char]
chartPath <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
fp Relationships
rels RefId
rId
          ChartSpace
chart <- Archive -> [Char] -> Parser ChartSpace
readChart Archive
ar [Char]
chartPath
          Anchor FileInfo ChartSpace
-> Either ParseError (Anchor FileInfo ChartSpace)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Anchor RefId RefId
uAnch {_anchObject = Graphic nv chart tr}
    lookupFI :: Relationships -> Maybe RefId -> Either ParseError (Maybe FileInfo)
lookupFI Relationships
_ Maybe RefId
Nothing = Maybe FileInfo -> Either ParseError (Maybe FileInfo)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileInfo
forall a. Maybe a
Nothing
    lookupFI Relationships
rels (Just RefId
rId) = do
      [Char]
path <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
fp Relationships
rels RefId
rId
        -- content types use paths starting with /
      Text
contentType <-
        ParseError -> Maybe Text -> Either ParseError Text
forall a b. a -> Maybe b -> Either a b
note ([Char] -> Text -> ParseError
InvalidFile [Char]
path Text
"Missing content type") (Maybe Text -> Either ParseError Text)
-> Maybe Text -> Either ParseError Text
forall a b. (a -> b) -> a -> b
$
        [Char] -> ContentTypes -> Maybe Text
ContentTypes.lookup ([Char]
"/" [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
path) ContentTypes
contentTypes
      ByteString
contents <-
        Entry -> ByteString
Zip.fromEntry (Entry -> ByteString)
-> Either ParseError Entry -> Either ParseError ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParseError -> Maybe Entry -> Either ParseError Entry
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
path) ([Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
path Archive
ar)
      Maybe FileInfo -> Either ParseError (Maybe FileInfo)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe FileInfo -> Either ParseError (Maybe FileInfo))
-> (FileInfo -> Maybe FileInfo)
-> FileInfo
-> Either ParseError (Maybe FileInfo)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FileInfo -> Maybe FileInfo
forall a. a -> Maybe a
Just (FileInfo -> Either ParseError (Maybe FileInfo))
-> FileInfo -> Either ParseError (Maybe FileInfo)
forall a b. (a -> b) -> a -> b
$ [Char] -> Text -> ByteString -> FileInfo
FileInfo (ShowS
stripMediaPrefix [Char]
path) Text
contentType ByteString
contents
    stripMediaPrefix :: FilePath -> FilePath
    stripMediaPrefix :: ShowS
stripMediaPrefix [Char]
p = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
p (Maybe [Char] -> [Char]) -> Maybe [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> Maybe [Char]
forall a. Eq a => [a] -> [a] -> Maybe [a]
stripPrefix [Char]
"xl/media/" [Char]
p

readChart :: Zip.Archive -> FilePath -> Parser ChartSpace
readChart :: Archive -> [Char] -> Parser ChartSpace
readChart Archive
ar [Char]
path = Archive -> [Char] -> Text -> Parser ChartSpace
forall a. FromCursor a => Archive -> [Char] -> Text -> Parser a
fromFileCursor Archive
ar [Char]
path Text
"chart"

-- | readWorkbook pulls the names of the sheets and the defined names
readWorkbook :: Zip.Archive -> Parser ([WorksheetFile], DefinedNames, Caches, DateBase)
readWorkbook :: Archive -> Parser ([WorksheetFile], DefinedNames, Caches, DateBase)
readWorkbook Archive
ar = do
  let wbPath :: a
wbPath = a
"xl/workbook.xml"
  Cursor
cur <- Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
forall {a}. IsString a => a
wbPath
  Relationships
wbRels <- Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
forall {a}. IsString a => a
wbPath
  -- Specification says the 'name' is required.
  let mkDefinedName :: Cursor -> [(Text, Maybe Text, Text)]
      mkDefinedName :: Cursor -> [(Text, Maybe Text, Text)]
mkDefinedName Cursor
c =
        (Text, Maybe Text, Text) -> [(Text, Maybe Text, Text)]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return
          ( [Char] -> [Text] -> Text
forall a. Partial => [Char] -> [a] -> a
headNote [Char]
"Missing name attribute" ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ Name -> Cursor -> [Text]
attribute Name
"name" Cursor
c
          , [Text] -> Maybe Text
forall a. [a] -> Maybe a
listToMaybe ([Text] -> Maybe Text) -> [Text] -> Maybe Text
forall a b. (a -> b) -> a -> b
$ Name -> Cursor -> [Text]
attribute Name
"localSheetId" Cursor
c
          , [Text] -> Text
T.concat ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ Cursor
c Cursor -> (Cursor -> [Text]) -> [Text]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Cursor -> [Text]
content)
      names :: [(Text, Maybe Text, Text)]
names =
        Cursor
cur Cursor
-> (Cursor -> [(Text, Maybe Text, Text)])
-> [(Text, Maybe Text, Text)]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"definedNames") Axis
-> (Cursor -> [(Text, Maybe Text, Text)])
-> Cursor
-> [(Text, Maybe Text, Text)]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"definedName") Axis
-> (Cursor -> [(Text, Maybe Text, Text)])
-> Cursor
-> [(Text, Maybe Text, Text)]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
        Cursor -> [(Text, Maybe Text, Text)]
mkDefinedName
  [WorksheetFile]
sheets <-
    [Either ParseError WorksheetFile]
-> Either ParseError [WorksheetFile]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([Either ParseError WorksheetFile]
 -> Either ParseError [WorksheetFile])
-> [Either ParseError WorksheetFile]
-> Either ParseError [WorksheetFile]
forall a b. (a -> b) -> a -> b
$
    Cursor
cur Cursor
-> (Cursor -> [Either ParseError WorksheetFile])
-> [Either ParseError WorksheetFile]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"sheets") Axis
-> (Cursor -> [Either ParseError WorksheetFile])
-> Cursor
-> [Either ParseError WorksheetFile]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"sheet") Axis
-> (Cursor -> [Either ParseError WorksheetFile])
-> Cursor
-> [Either ParseError WorksheetFile]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
    (Text -> SheetState -> RefId -> Either ParseError WorksheetFile)
-> [Text]
-> [SheetState]
-> [RefId]
-> [Either ParseError WorksheetFile]
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 ([Char]
-> Relationships
-> Text
-> SheetState
-> RefId
-> Either ParseError WorksheetFile
worksheetFile [Char]
forall {a}. IsString a => a
wbPath Relationships
wbRels) ([Text]
 -> [SheetState] -> [RefId] -> [Either ParseError WorksheetFile])
-> (Cursor -> [Text])
-> Cursor
-> [SheetState]
-> [RefId]
-> [Either ParseError WorksheetFile]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> Cursor -> [Text]
attribute Name
"name" (Cursor
 -> [SheetState] -> [RefId] -> [Either ParseError WorksheetFile])
-> (Cursor -> [SheetState])
-> Cursor
-> [RefId]
-> [Either ParseError WorksheetFile]
forall a b. (Cursor -> a -> b) -> (Cursor -> a) -> Cursor -> b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> SheetState -> Cursor -> [SheetState]
forall a. FromAttrVal a => Name -> a -> Cursor -> [a]
fromAttributeDef Name
"state" SheetState
forall a. Default a => a
def (Cursor -> [RefId] -> [Either ParseError WorksheetFile])
-> (Cursor -> [RefId])
-> Cursor
-> [Either ParseError WorksheetFile]
forall a b. (Cursor -> a -> b) -> (Cursor -> a) -> Cursor -> b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Name -> Cursor -> [RefId]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute (Text -> Name
odr Text
"id")
  let cacheRefs :: [(a, b)]
cacheRefs =
        Cursor
cur Cursor -> (Cursor -> [(a, b)]) -> [(a, b)]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"pivotCaches") Axis -> (Cursor -> [(a, b)]) -> Cursor -> [(a, b)]
forall node a.
Axis node -> (Cursor node -> [a]) -> Cursor node -> [a]
&/ Name -> Axis
element (Text -> Name
n_ Text
"pivotCache") Axis -> (Cursor -> [(a, b)]) -> Cursor -> [(a, b)]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
        (a -> b -> (a, b)) -> [a] -> [b] -> [(a, b)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) ([a] -> [b] -> [(a, b)])
-> (Cursor -> [a]) -> Cursor -> [b] -> [(a, b)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> Cursor -> [a]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"cacheId" (Cursor -> [b] -> [(a, b)])
-> (Cursor -> [b]) -> Cursor -> [(a, b)]
forall a b. (Cursor -> a -> b) -> (Cursor -> a) -> Cursor -> b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Name -> Cursor -> [b]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute (Text -> Name
odr Text
"id")
  Caches
caches <-
    [(CacheId, RefId)]
-> ((CacheId, RefId)
    -> Either ParseError (CacheId, (Text, Range, [CacheField])))
-> Either ParseError Caches
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [(CacheId, RefId)]
forall {a} {b}. (FromAttrVal a, FromAttrVal b) => [(a, b)]
cacheRefs (((CacheId, RefId)
  -> Either ParseError (CacheId, (Text, Range, [CacheField])))
 -> Either ParseError Caches)
-> ((CacheId, RefId)
    -> Either ParseError (CacheId, (Text, Range, [CacheField])))
-> Either ParseError Caches
forall a b. (a -> b) -> a -> b
$ \(CacheId
cacheId, RefId
rId) -> do
      [Char]
path <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
forall {a}. IsString a => a
wbPath Relationships
wbRels RefId
rId
      ByteString
bs <-
        ParseError -> Maybe ByteString -> Either ParseError ByteString
forall a b. a -> Maybe b -> Either a b
note ([Char] -> ParseError
MissingFile [Char]
path) (Maybe ByteString -> Either ParseError ByteString)
-> Maybe ByteString -> Either ParseError ByteString
forall a b. (a -> b) -> a -> b
$ Entry -> ByteString
Zip.fromEntry (Entry -> ByteString) -> Maybe Entry -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Archive -> Maybe Entry
Zip.findEntryByPath [Char]
path Archive
ar
      (Text
sheet, Range
ref, [CacheField]
fields0, Maybe RefId
mRecRId) <-
        ParseError
-> Maybe (Text, Range, [CacheField], Maybe RefId)
-> Either ParseError (Text, Range, [CacheField], Maybe RefId)
forall a b. a -> Maybe b -> Either a b
note (Text -> ParseError
InconsistentXlsx (Text -> ParseError) -> Text -> ParseError
forall a b. (a -> b) -> a -> b
$ Text
"Bad pivot table cache in " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack [Char]
path) (Maybe (Text, Range, [CacheField], Maybe RefId)
 -> Either ParseError (Text, Range, [CacheField], Maybe RefId))
-> Maybe (Text, Range, [CacheField], Maybe RefId)
-> Either ParseError (Text, Range, [CacheField], Maybe RefId)
forall a b. (a -> b) -> a -> b
$
        ByteString -> Maybe (Text, Range, [CacheField], Maybe RefId)
parseCache ByteString
bs
      [CacheField]
fields <- case Maybe RefId
mRecRId of
        Just RefId
recId -> do
          Relationships
cacheRels <- Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
path
          [Char]
recsPath <- [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
path Relationships
cacheRels RefId
recId
          Cursor
rCur <- Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
recsPath
          let recs :: [[CacheRecordValue]]
recs = Cursor
rCur Cursor -> (Cursor -> [[CacheRecordValue]]) -> [[CacheRecordValue]]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"r") Axis
-> (Cursor -> [[CacheRecordValue]])
-> Cursor
-> [[CacheRecordValue]]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \Cursor
cur' ->
                [CacheRecordValue] -> [[CacheRecordValue]]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([CacheRecordValue] -> [[CacheRecordValue]])
-> [CacheRecordValue] -> [[CacheRecordValue]]
forall a b. (a -> b) -> a -> b
$ Cursor
cur' Cursor -> (Cursor -> [CacheRecordValue]) -> [CacheRecordValue]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Axis
anyElement Axis
-> (Cursor -> [CacheRecordValue]) -> Cursor -> [CacheRecordValue]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Node -> [CacheRecordValue]
recordValueFromNode (Node -> [CacheRecordValue])
-> (Cursor -> Node) -> Cursor -> [CacheRecordValue]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> Node
forall node. Cursor node -> node
node
          [CacheField] -> Either ParseError [CacheField]
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return ([CacheField] -> Either ParseError [CacheField])
-> [CacheField] -> Either ParseError [CacheField]
forall a b. (a -> b) -> a -> b
$ [CacheField] -> [[CacheRecordValue]] -> [CacheField]
fillCacheFieldsFromRecords [CacheField]
fields0 [[CacheRecordValue]]
recs
        Maybe RefId
Nothing ->
          [CacheField] -> Either ParseError [CacheField]
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return [CacheField]
fields0
      (CacheId, (Text, Range, [CacheField]))
-> Either ParseError (CacheId, (Text, Range, [CacheField]))
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return ((CacheId, (Text, Range, [CacheField]))
 -> Either ParseError (CacheId, (Text, Range, [CacheField])))
-> (CacheId, (Text, Range, [CacheField]))
-> Either ParseError (CacheId, (Text, Range, [CacheField]))
forall a b. (a -> b) -> a -> b
$ (CacheId
cacheId, (Text
sheet, Range
ref, [CacheField]
fields))
  let dateBase :: DateBase
dateBase = DateBase -> DateBase -> Bool -> DateBase
forall a. a -> a -> Bool -> a
bool DateBase
DateBase1900 DateBase
DateBase1904 (Bool -> DateBase) -> ([Bool] -> Bool) -> [Bool] -> DateBase
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False (Maybe Bool -> Bool) -> ([Bool] -> Maybe Bool) -> [Bool] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Bool] -> Maybe Bool
forall a. [a] -> Maybe a
listToMaybe ([Bool] -> DateBase) -> [Bool] -> DateBase
forall a b. (a -> b) -> a -> b
$
                 Cursor
cur Cursor -> (Cursor -> [Bool]) -> [Bool]
forall node a. Cursor node -> (Cursor node -> [a]) -> [a]
$/ Name -> Axis
element (Text -> Name
n_ Text
"workbookPr") Axis -> (Cursor -> [Bool]) -> Cursor -> [Bool]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Name -> Cursor -> [Bool]
forall a. FromAttrVal a => Name -> Cursor -> [a]
fromAttribute Name
"date1904"
  ([WorksheetFile], DefinedNames, Caches, DateBase)
-> Parser ([WorksheetFile], DefinedNames, Caches, DateBase)
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return ([WorksheetFile]
sheets, [(Text, Maybe Text, Text)] -> DefinedNames
DefinedNames [(Text, Maybe Text, Text)]
names, Caches
caches, DateBase
dateBase)

getTable :: Zip.Archive -> FilePath -> Parser Table
getTable :: Archive -> [Char] -> Either ParseError Table
getTable Archive
ar [Char]
fp = do
  Cursor
cur <- Archive -> [Char] -> Either ParseError Cursor
xmlCursorRequired Archive
ar [Char]
fp
  ParseError -> [Table] -> Either ParseError Table
forall e a. e -> [a] -> Either e a
headErr ([Char] -> Text -> ParseError
InvalidFile [Char]
fp Text
"Couldn't parse drawing") (Cursor -> [Table]
forall a. FromCursor a => Cursor -> [a]
fromCursor Cursor
cur)

worksheetFile :: FilePath -> Relationships -> Text -> SheetState -> RefId -> Parser WorksheetFile
worksheetFile :: [Char]
-> Relationships
-> Text
-> SheetState
-> RefId
-> Either ParseError WorksheetFile
worksheetFile [Char]
parentPath Relationships
wbRels Text
name SheetState
visibility RefId
rId =
  Text -> SheetState -> [Char] -> WorksheetFile
WorksheetFile Text
name SheetState
visibility ([Char] -> WorksheetFile)
-> Either ParseError [Char] -> Either ParseError WorksheetFile
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
parentPath Relationships
wbRels RefId
rId

getRels :: Zip.Archive -> FilePath -> Parser Relationships
getRels :: Archive -> [Char] -> Parser Relationships
getRels Archive
ar [Char]
fp = do
    let ([Char]
dir, [Char]
file) = [Char] -> ([Char], [Char])
splitFileName [Char]
fp
        relsPath :: [Char]
relsPath = [Char]
dir [Char] -> ShowS
</> [Char]
"_rels" [Char] -> ShowS
</> [Char]
file [Char] -> ShowS
<.> [Char]
"rels"
    Maybe Cursor
c <- Archive -> [Char] -> Parser (Maybe Cursor)
xmlCursorOptional Archive
ar [Char]
relsPath
    Relationships -> Parser Relationships
forall a. a -> Either ParseError a
forall (m :: * -> *) a. Monad m => a -> m a
return (Relationships -> Parser Relationships)
-> Relationships -> Parser Relationships
forall a b. (a -> b) -> a -> b
$ Relationships
-> (Cursor -> Relationships) -> Maybe Cursor -> Relationships
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Relationships
Relationships.empty ([Char] -> Relationships -> Relationships
setTargetsFrom [Char]
fp (Relationships -> Relationships)
-> (Cursor -> Relationships) -> Cursor -> Relationships
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Relationships] -> Relationships
forall a. Partial => [Char] -> [a] -> a
headNote [Char]
"Missing rels" ([Relationships] -> Relationships)
-> (Cursor -> [Relationships]) -> Cursor -> Relationships
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cursor -> [Relationships]
forall a. FromCursor a => Cursor -> [a]
fromCursor) Maybe Cursor
c

-- According to part 2, section 7.3.4 of ECMA-376, when mapping logical item
-- names to ZIP item names we need to remove the leading slash.
--
-- Non-ASCII characters should be percent-encoded as well, but this is not
-- currently implemented.
--
-- https://ecma-international.org/publications-and-standards/standards/ecma-376/
logicalNameToZipItemName :: FilePath -> FilePath
logicalNameToZipItemName :: ShowS
logicalNameToZipItemName (Char
'/' : [Char]
name) = [Char]
name
logicalNameToZipItemName [Char]
name = [Char]
name

lookupRelPath :: FilePath
              -> Relationships
              -> RefId
              -> Either ParseError FilePath
lookupRelPath :: [Char] -> Relationships -> RefId -> Either ParseError [Char]
lookupRelPath [Char]
fp Relationships
rels RefId
rId =
  ShowS
logicalNameToZipItemName ShowS -> (Relationship -> [Char]) -> Relationship -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relationship -> [Char]
relTarget (Relationship -> [Char])
-> Either ParseError Relationship -> Either ParseError [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParseError -> Maybe Relationship -> Either ParseError Relationship
forall a b. a -> Maybe b -> Either a b
note ([Char] -> RefId -> ParseError
InvalidRef [Char]
fp RefId
rId) (RefId -> Relationships -> Maybe Relationship
Relationships.lookup RefId
rId Relationships
rels)