{- | Data types for working with the metadata of epub documents

   This module defines the Metadata structure which contains most of the taxonomic information about the literary work. Metadata is probably the most important data structure in this library.

   Both commonly-used versions of epub (2.x and 3.x) are supported by these types.
-}
module Codec.Epub.Data.Metadata
   ( Creator (..)
   , DateEvent (..)
   , DateValue (..)
   , Description (..)
   , Identifier (..)
   , Metadata (..)
   , Refinement (..)
   , Source (..)
   , Title (..)
   , dateEventFromString
   , dateEventToString
   , emptyMetadata
   , refineCreator
   , refineIdentifier
   , refineSource
   , refineTitle
   )
   where

import Control.Monad ( mplus )
import Data.List ( find )
import qualified Data.Map.Strict as Map
import Data.Map.Strict ( Map )


{- | Refinements represent meta tags within the metadata section
   that refine other tags. These are used during the parsing phase
   and are discarded as their information is slotted into the data
   they refine (CreatorS, TitleS, IdentifierS, etc..)

   This is specific to epub3
-}
data Refinement = Refinement
   { Refinement -> String
refId :: String  -- ^ id attribute
   , Refinement -> String
refProp :: String  -- ^ property attribute
   , Refinement -> String
refScheme :: String  -- ^ scheme attribute
   , Refinement -> String
refText :: String  -- ^ meta tag text
   }
   deriving Int -> Refinement -> ShowS
[Refinement] -> ShowS
Refinement -> String
(Int -> Refinement -> ShowS)
-> (Refinement -> String)
-> ([Refinement] -> ShowS)
-> Show Refinement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Refinement -> ShowS
showsPrec :: Int -> Refinement -> ShowS
$cshow :: Refinement -> String
show :: Refinement -> String
$cshowList :: [Refinement] -> ShowS
showList :: [Refinement] -> ShowS
Show


{- Used for locating specific meta information in a list of
   Refinements. The data from these meta tags is related to other
   tags by an XML id attribute.
-}
findByIdProp :: String -> String -> [Refinement] -> Maybe Refinement
findByIdProp :: String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
i String
prop = (Refinement -> Bool) -> [Refinement] -> Maybe Refinement
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\Refinement
r -> Refinement -> String
refId Refinement
r String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
i Bool -> Bool -> Bool
&& Refinement -> String
refProp Refinement
r String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
prop)


-- | package\/metadata\/dc:identifier tag
data Identifier = Identifier
   { Identifier -> Maybe String
idId :: Maybe String  -- ^ id attribute
   , Identifier -> Maybe String
idType :: Maybe String  -- ^ identifier-type property from meta tag
   , Identifier -> Maybe String
idScheme :: Maybe String  -- ^ scheme from attribute or meta tag
   , Identifier -> String
idText :: String  -- ^ identifier tag text
   }
   deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
/= :: Identifier -> Identifier -> Bool
Eq, Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Identifier -> ShowS
showsPrec :: Int -> Identifier -> ShowS
$cshow :: Identifier -> String
show :: Identifier -> String
$cshowList :: [Identifier] -> ShowS
showList :: [Identifier] -> ShowS
Show)


{- | Used internally by Codec.Epub.Parse.Metadata to merge epub3 meta
   tag info into the data gathered from an identifier tag
-}
refineIdentifier :: [Refinement] -> Identifier -> Identifier
refineIdentifier :: [Refinement] -> Identifier -> Identifier
refineIdentifier [Refinement]
refinements Identifier
ident = Identifier -> Identifier
assignScheme (Identifier -> Identifier)
-> (Identifier -> Identifier) -> Identifier -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Identifier
assignType (Identifier -> Identifier) -> Identifier -> Identifier
forall a b. (a -> b) -> a -> b
$ Identifier
ident
   where
      idTypeMeta :: Maybe Refinement
idTypeMeta = String -> String -> [Refinement] -> Maybe Refinement
findByIdProp (String -> ShowS -> Maybe String -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"" ShowS
forall a. a -> a
id (Maybe String -> String) -> Maybe String -> String
forall a b. (a -> b) -> a -> b
$ Identifier -> Maybe String
idId Identifier
ident)
         String
"identifier-type" [Refinement]
refinements

      assignType :: Identifier -> Identifier
assignType Identifier
ident' = Identifier
ident' { idType = refText `fmap` idTypeMeta }

      assignScheme :: Identifier -> Identifier
assignScheme Identifier
ident' =
         let existingScheme :: Maybe String
existingScheme = Identifier -> Maybe String
idScheme Identifier
ident'
         in Identifier
ident' { idScheme = existingScheme `mplus`
               (refScheme `fmap` idTypeMeta) }


-- | package\/metadata\/dc:title tag
data Title = Title
   { Title -> Maybe String
titleLang :: Maybe String  -- ^ lang attribute
   , Title -> Maybe String
titleType :: Maybe String  -- ^ title-type property from meta tag
   , Title -> Maybe Int
titleSeq :: Maybe Int  -- ^ display-sequence property from meta
   , Title -> String
titleText :: String  -- ^ title tag text
   }
   deriving (Title -> Title -> Bool
(Title -> Title -> Bool) -> (Title -> Title -> Bool) -> Eq Title
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Title -> Title -> Bool
== :: Title -> Title -> Bool
$c/= :: Title -> Title -> Bool
/= :: Title -> Title -> Bool
Eq, Int -> Title -> ShowS
[Title] -> ShowS
Title -> String
(Int -> Title -> ShowS)
-> (Title -> String) -> ([Title] -> ShowS) -> Show Title
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Title -> ShowS
showsPrec :: Int -> Title -> ShowS
$cshow :: Title -> String
show :: Title -> String
$cshowList :: [Title] -> ShowS
showList :: [Title] -> ShowS
Show)


{- | Used internally by Codec.Epub.Parse.Metadata to merge epub3 meta
   tag info into the data gathered from a title tag
-}
refineTitle :: [Refinement] -> (String, Title) -> Title
refineTitle :: [Refinement] -> (String, Title) -> Title
refineTitle [Refinement]
refinements (String
elid, Title
title) = Title -> Title
assignSeq (Title -> Title) -> (Title -> Title) -> Title -> Title
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Title -> Title
assignType (Title -> Title) -> Title -> Title
forall a b. (a -> b) -> a -> b
$ Title
title
   where
      assignType :: Title -> Title
assignType Title
title' =
         let newTy :: Maybe String
newTy = Refinement -> String
refText (Refinement -> String) -> Maybe Refinement -> Maybe String
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap`
               String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"title-type" [Refinement]
refinements
         in Title
title' { titleType = newTy }

      assignSeq :: Title -> Title
assignSeq Title
title' =
         let sq :: Maybe Int
sq = Maybe Int
-> (Refinement -> Maybe Int) -> Maybe Refinement -> Maybe Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe Int
forall a. Maybe a
Nothing (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int)
-> (Refinement -> Int) -> Refinement -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Int
forall a. Read a => String -> a
read (String -> Int) -> (Refinement -> String) -> Refinement -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Refinement -> String
refText) (Maybe Refinement -> Maybe Int) -> Maybe Refinement -> Maybe Int
forall a b. (a -> b) -> a -> b
$
               String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"display-seq" [Refinement]
refinements
         in Title
title' { titleSeq = sq }


{- | package\/metadata\/dc:creator or package\/metadata\/dc:contributor
   tags

   This structure is used for both contributor and creator as they are exactly the same.
-}
data Creator = Creator
   { Creator -> Maybe String
creatorRole :: Maybe String  -- ^ role from attribute or meta tag
   , Creator -> Maybe String
creatorFileAs :: Maybe String  -- ^ file-as from attribute or meta tag
   , Creator -> Maybe Int
creatorSeq :: Maybe Int  -- ^ display-sequence property from meta
   , Creator -> String
creatorText :: String  -- ^ creator or contributor tag text
   }
   deriving (Creator -> Creator -> Bool
(Creator -> Creator -> Bool)
-> (Creator -> Creator -> Bool) -> Eq Creator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Creator -> Creator -> Bool
== :: Creator -> Creator -> Bool
$c/= :: Creator -> Creator -> Bool
/= :: Creator -> Creator -> Bool
Eq, Int -> Creator -> ShowS
[Creator] -> ShowS
Creator -> String
(Int -> Creator -> ShowS)
-> (Creator -> String) -> ([Creator] -> ShowS) -> Show Creator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Creator -> ShowS
showsPrec :: Int -> Creator -> ShowS
$cshow :: Creator -> String
show :: Creator -> String
$cshowList :: [Creator] -> ShowS
showList :: [Creator] -> ShowS
Show)


{- | Used internally by Codec.Epub.Parse.Metadata to merge epub3 meta
   tag info into the data gathered from contributor and creator tags
-}
refineCreator :: [Refinement] -> (String, Creator) -> Creator
refineCreator :: [Refinement] -> (String, Creator) -> Creator
refineCreator [Refinement]
refinements (String
elid, Creator
creator) =
   Creator -> Creator
assignSeq (Creator -> Creator) -> (Creator -> Creator) -> Creator -> Creator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Creator -> Creator
assignFileAs (Creator -> Creator) -> (Creator -> Creator) -> Creator -> Creator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Creator -> Creator
assignRole (Creator -> Creator) -> Creator -> Creator
forall a b. (a -> b) -> a -> b
$ Creator
creator

   where
      assignRole :: Creator -> Creator
assignRole Creator
creator' =
         let existingRole :: Maybe String
existingRole = Creator -> Maybe String
creatorRole Creator
creator'
             metaRole :: Maybe String
metaRole = Maybe String
-> (Refinement -> Maybe String) -> Maybe Refinement -> Maybe String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe String
forall a. Maybe a
Nothing (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String)
-> (Refinement -> String) -> Refinement -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Refinement -> String
refText) (Maybe Refinement -> Maybe String)
-> Maybe Refinement -> Maybe String
forall a b. (a -> b) -> a -> b
$
               String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"role" [Refinement]
refinements
         in Creator
creator' { creatorRole = existingRole `mplus` metaRole }

      assignFileAs :: Creator -> Creator
assignFileAs Creator
creator' =
         let existingFileAs :: Maybe String
existingFileAs = Creator -> Maybe String
creatorFileAs Creator
creator'
             metaFileAs :: Maybe String
metaFileAs = Maybe String
-> (Refinement -> Maybe String) -> Maybe Refinement -> Maybe String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe String
forall a. Maybe a
Nothing (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String)
-> (Refinement -> String) -> Refinement -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Refinement -> String
refText) (Maybe Refinement -> Maybe String)
-> Maybe Refinement -> Maybe String
forall a b. (a -> b) -> a -> b
$
               String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"file-as" [Refinement]
refinements
         in Creator
creator' { creatorFileAs = existingFileAs `mplus` metaFileAs }

      assignSeq :: Creator -> Creator
assignSeq Creator
creator' =
         let sq :: Maybe Int
sq = Maybe Int
-> (Refinement -> Maybe Int) -> Maybe Refinement -> Maybe Int
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe Int
forall a. Maybe a
Nothing (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int)
-> (Refinement -> Int) -> Refinement -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Int
forall a. Read a => String -> a
read (String -> Int) -> (Refinement -> String) -> Refinement -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Refinement -> String
refText) (Maybe Refinement -> Maybe Int) -> Maybe Refinement -> Maybe Int
forall a b. (a -> b) -> a -> b
$
               String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"display-seq" [Refinement]
refinements
         in Creator
creator' { creatorSeq = sq }


{- | package\/metadata\/dc:source tags
-}
data Source = Source
  { Source -> Maybe String
sourceType :: Maybe String
  , Source -> Maybe String
sourceScheme :: Maybe String
  , Source -> Maybe String
sourceSourceOf :: Maybe String
  , Source -> String
sourceText :: String
  }
  deriving (Source -> Source -> Bool
(Source -> Source -> Bool)
-> (Source -> Source -> Bool) -> Eq Source
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Source -> Source -> Bool
== :: Source -> Source -> Bool
$c/= :: Source -> Source -> Bool
/= :: Source -> Source -> Bool
Eq, Int -> Source -> ShowS
[Source] -> ShowS
Source -> String
(Int -> Source -> ShowS)
-> (Source -> String) -> ([Source] -> ShowS) -> Show Source
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Source -> ShowS
showsPrec :: Int -> Source -> ShowS
$cshow :: Source -> String
show :: Source -> String
$cshowList :: [Source] -> ShowS
showList :: [Source] -> ShowS
Show)

{- | Used internally by Codec.Epub.Parse.Metadata to merge epub3 meta
   tag info into the data gathered from contributor and creator tags
-}
refineSource :: [Refinement] -> (String, Source) -> Source
refineSource :: [Refinement] -> (String, Source) -> Source
refineSource [Refinement]
refinements (String
elid, Source
source) =
  Source -> Source
assignType (Source -> Source) -> (Source -> Source) -> Source -> Source
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Source -> Source
assignScheme (Source -> Source) -> (Source -> Source) -> Source -> Source
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Source -> Source
assignSourceOf (Source -> Source) -> Source -> Source
forall a b. (a -> b) -> a -> b
$ Source
source

  where
    idTypeMeta :: Maybe Refinement
idTypeMeta = String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"identifier-type" [Refinement]
refinements

    assignType :: Source -> Source
assignType Source
source' = Source
source' { sourceType = refText <$> idTypeMeta }

    assignScheme :: Source -> Source
assignScheme Source
source' = Source
source' { sourceScheme = refScheme <$> idTypeMeta }

    assignSourceOf :: Source -> Source
assignSourceOf Source
source' =
      let existingSourceOf :: Maybe String
existingSourceOf = Source -> Maybe String
sourceSourceOf Source
source'
          metaSourceOf :: Maybe String
metaSourceOf = Maybe String
-> (Refinement -> Maybe String) -> Maybe Refinement -> Maybe String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe String
forall a. Maybe a
Nothing (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String)
-> (Refinement -> String) -> Refinement -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Refinement -> String
refText) (Maybe Refinement -> Maybe String)
-> Maybe Refinement -> Maybe String
forall a b. (a -> b) -> a -> b
$
            String -> String -> [Refinement] -> Maybe Refinement
findByIdProp String
elid String
"source-of" [Refinement]
refinements
      in Source
source' { sourceSourceOf = existingSourceOf `mplus` metaSourceOf }


data DateEvent
  = Available
  | Created
  | Date
  | DateAccepted
  | DateCopyrighted
  | DateSubmitted
  | Epub
  | Issued
  | Modified
  | Valid
  deriving (DateEvent -> DateEvent -> Bool
(DateEvent -> DateEvent -> Bool)
-> (DateEvent -> DateEvent -> Bool) -> Eq DateEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateEvent -> DateEvent -> Bool
== :: DateEvent -> DateEvent -> Bool
$c/= :: DateEvent -> DateEvent -> Bool
/= :: DateEvent -> DateEvent -> Bool
Eq, Eq DateEvent
Eq DateEvent =>
(DateEvent -> DateEvent -> Ordering)
-> (DateEvent -> DateEvent -> Bool)
-> (DateEvent -> DateEvent -> Bool)
-> (DateEvent -> DateEvent -> Bool)
-> (DateEvent -> DateEvent -> Bool)
-> (DateEvent -> DateEvent -> DateEvent)
-> (DateEvent -> DateEvent -> DateEvent)
-> Ord DateEvent
DateEvent -> DateEvent -> Bool
DateEvent -> DateEvent -> Ordering
DateEvent -> DateEvent -> DateEvent
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DateEvent -> DateEvent -> Ordering
compare :: DateEvent -> DateEvent -> Ordering
$c< :: DateEvent -> DateEvent -> Bool
< :: DateEvent -> DateEvent -> Bool
$c<= :: DateEvent -> DateEvent -> Bool
<= :: DateEvent -> DateEvent -> Bool
$c> :: DateEvent -> DateEvent -> Bool
> :: DateEvent -> DateEvent -> Bool
$c>= :: DateEvent -> DateEvent -> Bool
>= :: DateEvent -> DateEvent -> Bool
$cmax :: DateEvent -> DateEvent -> DateEvent
max :: DateEvent -> DateEvent -> DateEvent
$cmin :: DateEvent -> DateEvent -> DateEvent
min :: DateEvent -> DateEvent -> DateEvent
Ord, Int -> DateEvent -> ShowS
[DateEvent] -> ShowS
DateEvent -> String
(Int -> DateEvent -> ShowS)
-> (DateEvent -> String)
-> ([DateEvent] -> ShowS)
-> Show DateEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateEvent -> ShowS
showsPrec :: Int -> DateEvent -> ShowS
$cshow :: DateEvent -> String
show :: DateEvent -> String
$cshowList :: [DateEvent] -> ShowS
showList :: [DateEvent] -> ShowS
Show)

dateEventFromString :: Maybe String -> Maybe DateEvent
dateEventFromString :: Maybe String -> Maybe DateEvent
dateEventFromString (Just String
"dcterms:available") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Available
dateEventFromString (Just String
"dcterms:created") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Created
dateEventFromString (Just String
"publication") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Created                      -- EPUB 2.x
dateEventFromString (Just String
"dcterms:date") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Date
dateEventFromString (Just String
"dcterms:dateAccepted") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
DateAccepted
dateEventFromString (Just String
"dcterms:dateCopyrighted") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
DateCopyrighted
dateEventFromString (Just String
"dcterms:dateSubmitted") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
DateSubmitted
dateEventFromString (Just String
"dcterms:issued") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Issued
dateEventFromString (Just String
"original-publication") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Issued              -- EPUB 2.x
dateEventFromString (Just String
"dcterms:modified") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Modified
dateEventFromString (Just String
"dcterms:valid") = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Valid
dateEventFromString Maybe String
Nothing = DateEvent -> Maybe DateEvent
forall a. a -> Maybe a
Just DateEvent
Epub
dateEventFromString Maybe String
_ = Maybe DateEvent
forall a. Maybe a
Nothing

dateEventToString :: DateEvent -> String
dateEventToString :: DateEvent -> String
dateEventToString DateEvent
Available = String
"available"
dateEventToString DateEvent
Created = String
"created"
dateEventToString DateEvent
Date = String
"date"
dateEventToString DateEvent
DateAccepted = String
"dateAccepted"
dateEventToString DateEvent
DateCopyrighted = String
"dateCopyrighted"
dateEventToString DateEvent
DateSubmitted = String
"dateSubmitted"
dateEventToString DateEvent
Epub = String
"EPUB created"
dateEventToString DateEvent
Issued = String
"issued"
dateEventToString DateEvent
Modified = String
"modified"
dateEventToString DateEvent
Valid = String
"valid"


-- | EPUB 2.x: package\/metadata\/dc:date tag, opf:event attribute, text
-- | EPUB 3.x: package\/metadata\/dc:date tag
-- |           package\/metadata\/meta property="dcterms:issued"
-- |           package\/metadata\/meta property="dcterms:modified"
-- |           package\/metadata\/meta property="dcterms:..."
newtype DateValue = DateValue String
   deriving (DateValue -> DateValue -> Bool
(DateValue -> DateValue -> Bool)
-> (DateValue -> DateValue -> Bool) -> Eq DateValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DateValue -> DateValue -> Bool
== :: DateValue -> DateValue -> Bool
$c/= :: DateValue -> DateValue -> Bool
/= :: DateValue -> DateValue -> Bool
Eq, Int -> DateValue -> ShowS
[DateValue] -> ShowS
DateValue -> String
(Int -> DateValue -> ShowS)
-> (DateValue -> String)
-> ([DateValue] -> ShowS)
-> Show DateValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DateValue -> ShowS
showsPrec :: Int -> DateValue -> ShowS
$cshow :: DateValue -> String
show :: DateValue -> String
$cshowList :: [DateValue] -> ShowS
showList :: [DateValue] -> ShowS
Show)


-- | package\/metadata\/dc:description tag, xml:lang attribute, text
data Description = Description (Maybe String) String
   deriving (Description -> Description -> Bool
(Description -> Description -> Bool)
-> (Description -> Description -> Bool) -> Eq Description
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Description -> Description -> Bool
== :: Description -> Description -> Bool
$c/= :: Description -> Description -> Bool
/= :: Description -> Description -> Bool
Eq, Int -> Description -> ShowS
[Description] -> ShowS
Description -> String
(Int -> Description -> ShowS)
-> (Description -> String)
-> ([Description] -> ShowS)
-> Show Description
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Description -> ShowS
showsPrec :: Int -> Description -> ShowS
$cshow :: Description -> String
show :: Description -> String
$cshowList :: [Description] -> ShowS
showList :: [Description] -> ShowS
Show)


{- | package\/metadata tag

   This is perhaps the most useful data structure in this library. It
   contains most of the information tools will want to use to
   organize epub documents.
-}
data Metadata = Metadata
   { Metadata -> [Identifier]
metaIds :: [Identifier]  -- ^ at least one required
   , Metadata -> [Title]
metaTitles :: [Title]  -- ^ at least one required
   , Metadata -> [String]
metaLangs :: [String]  -- ^ dc:language tags, at least one required
   , Metadata -> [Creator]
metaContributors :: [Creator]
   , Metadata -> [Creator]
metaCreators :: [Creator]
   , Metadata -> Map DateEvent DateValue
metaDates :: Map DateEvent DateValue
   , Metadata -> [Source]
metaSources :: [Source]  -- ^ dc:source tags
   , Metadata -> Maybe String
metaType :: Maybe String  -- ^ dc:type tags
   , Metadata -> [String]
metaCoverages :: [String]  -- ^ dc:coverage tags
   , Metadata -> [Description]
metaDescriptions :: [Description]
   , Metadata -> [String]
metaFormats :: [String]  -- ^ dc:format tags
   , Metadata -> [String]
metaPublishers :: [String]  -- ^ dc:publisher tags
   , Metadata -> [String]
metaRelations :: [String]  -- ^ dc:relation tags
   , Metadata -> [String]
metaRights :: [String]  -- ^ dc:rights tags
   , Metadata -> [String]
metaSubjects :: [String]  -- ^ dc:subject tags
   }
   deriving (Metadata -> Metadata -> Bool
(Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool) -> Eq Metadata
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Metadata -> Metadata -> Bool
== :: Metadata -> Metadata -> Bool
$c/= :: Metadata -> Metadata -> Bool
/= :: Metadata -> Metadata -> Bool
Eq, Int -> Metadata -> ShowS
[Metadata] -> ShowS
Metadata -> String
(Int -> Metadata -> ShowS)
-> (Metadata -> String) -> ([Metadata] -> ShowS) -> Show Metadata
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Metadata -> ShowS
showsPrec :: Int -> Metadata -> ShowS
$cshow :: Metadata -> String
show :: Metadata -> String
$cshowList :: [Metadata] -> ShowS
showList :: [Metadata] -> ShowS
Show)

-- | Note: This isn't valid as-is, some required values are empty lists!
emptyMetadata :: Metadata
emptyMetadata :: Metadata
emptyMetadata = Metadata
   { metaIds :: [Identifier]
metaIds = []  -- one required
   , metaTitles :: [Title]
metaTitles = []  -- one required
   , metaLangs :: [String]
metaLangs = []  -- one required
   , metaContributors :: [Creator]
metaContributors = []
   , metaCreators :: [Creator]
metaCreators = []
   , metaDates :: Map DateEvent DateValue
metaDates = Map DateEvent DateValue
forall k a. Map k a
Map.empty
   , metaSources :: [Source]
metaSources = []
   , metaType :: Maybe String
metaType = Maybe String
forall a. Maybe a
Nothing
   , metaCoverages :: [String]
metaCoverages = []
   , metaDescriptions :: [Description]
metaDescriptions = []
   , metaFormats :: [String]
metaFormats = []
   , metaPublishers :: [String]
metaPublishers = []
   , metaRelations :: [String]
metaRelations = []
   , metaRights :: [String]
metaRights = []
   , metaSubjects :: [String]
metaSubjects = []
   }