{-# LANGUAGE OverloadedStrings #-}
{- |
   Module      : Text.Pandoc.Readers.BibTeX
   Copyright   : Copyright (C) 2020-2023 John MacFarlane
   License     : GNU GPL, version 2 or above

   Maintainer  : John MacFarlane <jgm@berkeley.edu>
   Stability   : alpha
   Portability : portable

Parses BibTeX or BibLaTeX bibliographies into a Pandoc document
with empty body and `references` and `nocite` fields
in the metadata.  A wildcard `nocite` is used so that
if the document is rendered in another format, the
entire bibliography will be printed.
-}
module Text.Pandoc.Readers.BibTeX
  ( readBibTeX
  , readBibLaTeX
  )
where

import Text.Pandoc.Options
import Text.Pandoc.Definition
import Text.Pandoc.Builder (setMeta, cite, str)
import Text.Pandoc.Parsing (fromParsecError)
import Citeproc (Lang(..), parseLang)
import Citeproc.Locale (getLocale)
import Text.Pandoc.Error (PandocError(..))
import Text.Pandoc.Class (PandocMonad, lookupEnv)
import Text.Pandoc.Citeproc.BibTeX as BibTeX
import Text.Pandoc.Citeproc.MetaValue (referenceToMetaValue)
import Text.Pandoc.Sources (ToSources(..))
import Control.Monad.Except (throwError)

-- | Read BibTeX from an input string and return a Pandoc document.
-- The document will have only metadata, with an empty body.
-- The metadata will contain a `references` field with the
-- bibliography entries, and a `nocite` field with the wildcard `[@*]`.
readBibTeX :: (PandocMonad m, ToSources a)
           => ReaderOptions -> a -> m Pandoc
readBibTeX :: forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
ReaderOptions -> a -> m Pandoc
readBibTeX = forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
Variant -> ReaderOptions -> a -> m Pandoc
readBibTeX' Variant
BibTeX.Bibtex

-- | Read BibLaTeX from an input string and return a Pandoc document.
-- The document will have only metadata, with an empty body.
-- The metadata will contain a `references` field with the
-- bibliography entries, and a `nocite` field with the wildcard `[@*]`.
readBibLaTeX :: (PandocMonad m, ToSources a)
             => ReaderOptions -> a -> m Pandoc
readBibLaTeX :: forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
ReaderOptions -> a -> m Pandoc
readBibLaTeX = forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
Variant -> ReaderOptions -> a -> m Pandoc
readBibTeX' Variant
BibTeX.Biblatex

readBibTeX' :: (PandocMonad m, ToSources a)
            => Variant -> ReaderOptions -> a -> m Pandoc
readBibTeX' :: forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
Variant -> ReaderOptions -> a -> m Pandoc
readBibTeX' Variant
variant ReaderOptions
_opts a
t = do
  Maybe Text
mblangEnv <- forall (m :: * -> *). PandocMonad m => Text -> m (Maybe Text)
lookupEnv Text
"LANG"
  let defaultLang :: Lang
defaultLang = Text
-> Maybe Text
-> Maybe Text
-> [Text]
-> [(Text, [(Text, Text)])]
-> [Text]
-> Lang
Lang Text
"en" forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Text
"US") [] [] []
  let lang :: Lang
lang = case Maybe Text
mblangEnv of
              Maybe Text
Nothing  -> Lang
defaultLang
              Just Text
l   -> forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const Lang
defaultLang) forall a. a -> a
id forall a b. (a -> b) -> a -> b
$ Text -> Either String Lang
parseLang Text
l
  Locale
locale <- case Lang -> Either CiteprocError Locale
getLocale Lang
lang of
               Left CiteprocError
e  ->
                 case Lang -> Either CiteprocError Locale
getLocale (Text
-> Maybe Text
-> Maybe Text
-> [Text]
-> [(Text, [(Text, Text)])]
-> [Text]
-> Lang
Lang Text
"en" forall a. Maybe a
Nothing (forall a. a -> Maybe a
Just Text
"US") [] [] []) of
                   Right Locale
l -> forall (m :: * -> *) a. Monad m => a -> m a
return Locale
l
                   Left CiteprocError
_  -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ CiteprocError -> PandocError
PandocCiteprocError CiteprocError
e
               Right Locale
l -> forall (m :: * -> *) a. Monad m => a -> m a
return Locale
l
  case forall a.
ToSources a =>
Variant
-> Locale
-> (Text -> Bool)
-> a
-> Either ParseError [Reference Inlines]
BibTeX.readBibtexString Variant
variant Locale
locale (forall a b. a -> b -> a
const Bool
True) a
t of
    Left ParseError
e -> forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Sources -> ParseError -> PandocError
fromParsecError (forall a. ToSources a => a -> Sources
toSources a
t) ParseError
e
    Right [Reference Inlines]
refs -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
setMeta Text
"references"
                              (forall a b. (a -> b) -> [a] -> [b]
map Reference Inlines -> MetaValue
referenceToMetaValue [Reference Inlines]
refs)
                         forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
setMeta Text
"nocite"
                            ([Citation] -> Inlines -> Inlines
cite [Citation {citationId :: Text
citationId = Text
"*"
                                            , citationPrefix :: [Inline]
citationPrefix = []
                                            , citationSuffix :: [Inline]
citationSuffix = []
                                            , citationMode :: CitationMode
citationMode = CitationMode
NormalCitation
                                            , citationNoteNum :: Int
citationNoteNum = Int
0
                                            , citationHash :: Int
citationHash = Int
0}]
                                            (Text -> Inlines
str Text
"[@*]"))
                        forall a b. (a -> b) -> a -> b
$ Meta -> [Block] -> Pandoc
Pandoc Meta
nullMeta []