1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
|
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{- |
Module : Text.Pandoc.Translations
Copyright : Copyright (C) 2017-2021 John MacFarlane
License : GNU GPL, version 2 or above
Maintainer : John MacFarlane <jgm@berkeley.edu>
Stability : alpha
Portability : portable
Data types for localization.
Translations are stored in @data/translations/langname.trans@,
where langname can be the full BCP47 language specifier, or
just the language part. File format is:
> # A comment, ignored
> Figure: Figura
> Index: Indeksi
-}
module Text.Pandoc.Translations (
Term(..)
, Translations
, lookupTerm
, readTranslations
)
where
import Data.Aeson.Types (Value(..), FromJSON(..))
import qualified Data.Aeson.Types as Aeson
import qualified Data.Map as M
import qualified Data.Text as T
import qualified Data.Yaml as Yaml
import GHC.Generics (Generic)
import Text.Pandoc.Shared (safeRead)
import qualified Text.Pandoc.UTF8 as UTF8
import Data.Yaml (prettyPrintParseException)
data Term =
Abstract
| Appendix
| Bibliography
| Cc
| Chapter
| Contents
| Encl
| Figure
| Glossary
| Index
| Listing
| ListOfFigures
| ListOfTables
| Page
| Part
| Preface
| Proof
| References
| See
| SeeAlso
| Table
| To
deriving (Show, Eq, Ord, Generic, Enum, Read)
newtype Translations = Translations (M.Map Term T.Text)
deriving (Show, Generic, Semigroup, Monoid)
instance FromJSON Term where
parseJSON (String t) = case safeRead t of
Just t' -> pure t'
Nothing -> Prelude.fail $ "Invalid Term name " ++
show t
parseJSON invalid = Aeson.typeMismatch "Term" invalid
instance FromJSON Translations where
parseJSON o@(Object{}) = do
xs <- parseJSON o >>= mapM addItem . M.toList
return $ Translations (M.fromList xs)
where addItem (k,v) =
case safeRead k of
Nothing -> Prelude.fail $ "Invalid Term name " ++ show k
Just t ->
case v of
(String s) -> return (t, T.strip s)
inv -> Aeson.typeMismatch "String" inv
parseJSON invalid = Aeson.typeMismatch "Translations" invalid
lookupTerm :: Term -> Translations -> Maybe T.Text
lookupTerm t (Translations tm) = M.lookup t tm
readTranslations :: T.Text -> Either T.Text Translations
readTranslations s =
case Yaml.decodeAllEither' $ UTF8.fromText s of
Left err' -> Left $ T.pack $ prettyPrintParseException err'
Right (t:_) -> Right t
Right [] -> Left "empty YAML document"
|
