Merge tag 'upstream/2.1.2_dfsg'

Upstream version 2.1.2~dfsg

# gpg: Signature made Tue 24 Apr 2018 10:48:48 AM MST
# gpg:                using RSA key 9B917007AE030E36E4FC248B695B7AE4BF066240
# gpg:                issuer "spwhitton@spwhitton.name"
# gpg: Good signature from "Sean Whitton <spwhitton@spwhitton.name>" [ultimate]
# Primary key fingerprint: 8DC2 487E 51AB DD90 B5C4  753F 0F56 D055 3B6D 411B
#      Subkey fingerprint: 9B91 7007 AE03 0E36 E4FC  248B 695B 7AE4 BF06 6240

1 files changed, 144 insertions, 74 deletions

diff --git a/src/Text/Pandoc/Writers/ODT.hs b/src/Text/Pandoc/Writers/ODT.hs
index ce4d456a3..63a3f915a 100644
--- a/src/Text/Pandoc/Writers/ODT.hs
+++ b/src/Text/Pandoc/Writers/ODT.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-
-Copyright (C) 2008-2015 John MacFarlane <jgm@berkeley.edu>
+Copyright (C) 2008-2018 John MacFarlane <jgm@berkeley.edu>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 {- |
    Module      : Text.Pandoc.Writers.ODT
-   Copyright   : Copyright (C) 2008-2015 John MacFarlane
+   Copyright   : Copyright (C) 2008-2018 John MacFarlane
    License     : GNU GPL, version 2 or above
 
    Maintainer  : John MacFarlane <jgm@berkeley.edu>
@@ -29,49 +29,70 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Conversion of 'Pandoc' documents to ODT.
 -}
 module Text.Pandoc.Writers.ODT ( writeODT ) where
-import Data.IORef
-import Data.List ( isPrefixOf )
-import Data.Maybe ( fromMaybe )
-import Text.XML.Light.Output
-import Text.TeXMath
-import qualified Data.ByteString.Lazy as B
-import Text.Pandoc.UTF8 ( fromStringLazy )
 import Codec.Archive.Zip
-import Text.Pandoc.Options ( WriterOptions(..), WrapOption(..) )
-import Text.Pandoc.Shared ( stringify, fetchItem', warn,
-                            getDefaultReferenceODT )
-import Text.Pandoc.ImageSize
-import Text.Pandoc.MIME ( getMimeType, extensionFromMimeType )
+import Control.Monad.Except (catchError)
+import Control.Monad.State.Strict
+import qualified Data.ByteString.Lazy as B
+import Data.Generics (everywhere', mkT)
+import Data.List (isPrefixOf)
+import Data.Maybe (fromMaybe)
+import qualified Data.Text.Lazy as TL
+import System.FilePath (takeDirectory, takeExtension, (<.>))
+import Text.Pandoc.BCP47 (Lang (..), getLang, renderLang)
+import Text.Pandoc.Class (PandocMonad, report, toLang)
+import qualified Text.Pandoc.Class as P
 import Text.Pandoc.Definition
+import Text.Pandoc.ImageSize
+import Text.Pandoc.Logging
+import Text.Pandoc.MIME (extensionFromMimeType, getMimeType)
+import Text.Pandoc.Options (WrapOption (..), WriterOptions (..))
+import Text.Pandoc.Pretty
+import Text.Pandoc.Shared (stringify)
+import Text.Pandoc.UTF8 (fromStringLazy, fromTextLazy, toStringLazy)
 import Text.Pandoc.Walk
-import Text.Pandoc.Writers.Shared ( fixDisplayMath )
-import Text.Pandoc.Writers.OpenDocument ( writeOpenDocument )
-import Control.Monad (liftM)
+import Text.Pandoc.Writers.OpenDocument (writeOpenDocument)
+import Text.Pandoc.Writers.Shared (fixDisplayMath)
 import Text.Pandoc.XML
-import Text.Pandoc.Pretty
-import qualified Control.Exception as E
-import Data.Time.Clock.POSIX ( getPOSIXTime )
-import System.FilePath ( takeExtension, takeDirectory, (<.>))
+import Text.TeXMath
+import Text.XML.Light
+
+newtype ODTState = ODTState { stEntries :: [Entry]
+                         }
+
+type O m = StateT ODTState m
 
 -- | Produce an ODT file from a Pandoc document.
-writeODT :: WriterOptions  -- ^ Writer options
+writeODT :: PandocMonad m
+         => WriterOptions  -- ^ Writer options
          -> Pandoc         -- ^ Document to convert
-         -> IO B.ByteString
-writeODT opts doc@(Pandoc meta _) = do
-  let datadir = writerUserDataDir opts
+         -> m B.ByteString
+writeODT  opts doc =
+  let initState = ODTState{ stEntries = []
+                          }
+  in
+    evalStateT (pandocToODT opts doc) initState
+
+-- | Produce an ODT file from a Pandoc document.
+pandocToODT :: PandocMonad m
+            => WriterOptions  -- ^ Writer options
+            -> Pandoc         -- ^ Document to convert
+            -> O m B.ByteString
+pandocToODT opts doc@(Pandoc meta _) = do
   let title = docTitle meta
+  lang <- toLang (getLang opts meta)
   refArchive <-
-       case writerReferenceODT opts of
-             Just f -> liftM toArchive $ B.readFile f
-             Nothing -> getDefaultReferenceODT datadir
+       case writerReferenceDoc opts of
+             Just f -> liftM toArchive $ lift $ P.readFileLazy f
+             Nothing -> lift $ (toArchive . B.fromStrict) <$>
+                                P.readDataFile "reference.odt"
   -- handle formulas and pictures
-  picEntriesRef <- newIORef ([] :: [Entry])
-  doc' <- walkM (transformPicMath opts picEntriesRef) $ walk fixDisplayMath doc
-  let newContents = writeOpenDocument opts{writerWrapText = WrapNone} doc'
-  epochtime <- floor `fmap` getPOSIXTime
+  -- picEntriesRef <- P.newIORef ([] :: [Entry])
+  doc' <- walkM (transformPicMath opts) $ walk fixDisplayMath doc
+  newContents <- lift $ writeOpenDocument opts{writerWrapText = WrapNone} doc'
+  epochtime <- floor `fmap` lift P.getPOSIXTime
   let contentEntry = toEntry "content.xml" epochtime
-                     $ fromStringLazy newContents
-  picEntries <- readIORef picEntriesRef
+                     $ fromTextLazy $ TL.fromStrict newContents
+  picEntries <- gets stEntries
   let archive = foldr addEntryToArchive refArchive
                 $ contentEntry : picEntries
   -- construct META-INF/manifest.xml based on archive
@@ -90,14 +111,13 @@ writeODT opts doc@(Pandoc meta _) = do
         $ fromStringLazy $ render Nothing
         $ text "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
         $$
-         ( inTags True "manifest:manifest"
+         (inTags True "manifest:manifest"
             [("xmlns:manifest","urn:oasis:names:tc:opendocument:xmlns:manifest:1.0")
-            ,("manifest:version","1.2")]
-            $ ( selfClosingTag "manifest:file-entry"
+            ,("manifest:version","1.2")] ( selfClosingTag "manifest:file-entry"
                  [("manifest:media-type","application/vnd.oasis.opendocument.text")
                  ,("manifest:full-path","/")]
-                $$ vcat ( map toFileEntry $ files )
-                $$ vcat ( map toFileEntry $ formulas )
+                $$ vcat ( map toFileEntry files )
+                $$ vcat ( map toFileEntry formulas )
               )
          )
   let archive' = addEntryToArchive manifestEntry archive
@@ -105,88 +125,138 @@ writeODT opts doc@(Pandoc meta _) = do
        $ fromStringLazy $ render Nothing
        $ text "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
        $$
-        ( inTags True "office:document-meta"
+        (inTags True "office:document-meta"
            [("xmlns:office","urn:oasis:names:tc:opendocument:xmlns:office:1.0")
            ,("xmlns:xlink","http://www.w3.org/1999/xlink")
            ,("xmlns:dc","http://purl.org/dc/elements/1.1/")
            ,("xmlns:meta","urn:oasis:names:tc:opendocument:xmlns:meta:1.0")
            ,("xmlns:ooo","http://openoffice.org/2004/office")
            ,("xmlns:grddl","http://www.w3.org/2003/g/data-view#")
-           ,("office:version","1.2")]
-           $ ( inTagsSimple "office:meta"
-                $ ( inTagsSimple "dc:title" (text $ escapeStringForXML (stringify title))
-                  )
+           ,("office:version","1.2")] ( inTagsSimple "office:meta" $
+                 ( inTagsSimple "dc:title"
+                      (text $ escapeStringForXML (stringify title))
+                   $$
+                   case lang of
+                        Just l -> inTagsSimple "dc:language"
+                                    (text (escapeStringForXML (renderLang l)))
+                        Nothing -> empty
+                 )
              )
         )
   -- make sure mimetype is first
   let mimetypeEntry = toEntry "mimetype" epochtime
                       $ fromStringLazy "application/vnd.oasis.opendocument.text"
-  let archive'' = addEntryToArchive mimetypeEntry
+  archive'' <- updateStyleWithLang lang
+                  $ addEntryToArchive mimetypeEntry
                   $ addEntryToArchive metaEntry archive'
   return $ fromArchive archive''
 
+updateStyleWithLang :: PandocMonad m => Maybe Lang -> Archive -> O m Archive
+updateStyleWithLang Nothing arch = return arch
+updateStyleWithLang (Just lang) arch = do
+  epochtime <- floor `fmap` lift P.getPOSIXTime
+  return arch{ zEntries = [if eRelativePath e == "styles.xml"
+                              then case parseXMLDoc
+                                      (toStringLazy (fromEntry e)) of
+                                      Nothing -> e
+                                      Just d ->
+                                        toEntry "styles.xml" epochtime
+                                        ( fromStringLazy
+                                        . ppTopElement
+                                        . addLang lang $ d )
+                              else e
+                            | e <- zEntries arch] }
+
+addLang :: Lang -> Element -> Element
+addLang lang = everywhere' (mkT updateLangAttr)
+    where updateLangAttr (Attr n@(QName "language" _ (Just "fo")) _)
+                           = Attr n (langLanguage lang)
+          updateLangAttr (Attr n@(QName "country" _ (Just "fo")) _)
+                           = Attr n (langRegion lang)
+          updateLangAttr x = x
+
 -- | transform both Image and Math elements
-transformPicMath :: WriterOptions -> IORef [Entry] -> Inline -> IO Inline
-transformPicMath opts entriesRef (Image attr@(id', cls, _) lab (src,t)) = do
-  res <- fetchItem' (writerMediaBag opts) (writerSourceURL opts) src
-  case res of
-     Left (_ :: E.SomeException) -> do
-       warn $ "Could not find image `" ++ src ++ "', skipping..."
-       return $ Emph lab
-     Right (img, mbMimeType) -> do
-       (ptX, ptY) <- case imageSize img of
+transformPicMath :: PandocMonad m => WriterOptions ->Inline -> O m Inline
+transformPicMath opts (Image attr@(id', cls, _) lab (src,t)) = catchError
+   (do (img, mbMimeType) <- P.fetchItem src
+       (ptX, ptY) <- case imageSize opts img of
                        Right s  -> return $ sizeInPoints s
                        Left msg -> do
-                         warn $ "Could not determine image size in `" ++
-                           src ++ "': " ++ msg
+                         report $ CouldNotDetermineImageSize src msg
                          return (100, 100)
        let dims =
              case (getDim Width, getDim Height) of
                (Just w, Just h)              -> [("width", show w), ("height", show h)]
-               (Just w@(Percent _), Nothing) -> [("width", show w), ("style:rel-height", "scale")]
-               (Nothing, Just h@(Percent _)) -> [("style:rel-width", "scale"), ("height", show h)]
+               (Just w@(Percent p), Nothing) -> [("width", show w), ("height", show (p / ratio) ++ "%")]
+               (Nothing, Just h@(Percent p)) -> [("width", show (p * ratio) ++ "%"), ("height", show h)]
                (Just w@(Inch i), Nothing)    -> [("width", show w), ("height", show (i / ratio) ++ "in")]
                (Nothing, Just h@(Inch i))    -> [("width", show (i * ratio) ++ "in"), ("height", show h)]
                _                             -> [("width", show ptX ++ "pt"), ("height", show ptY ++ "pt")]
              where
                ratio = ptX / ptY
-               getDim dir = case (dimension dir attr) of
+               getDim dir = case dimension dir attr of
                               Just (Percent i) -> Just $ Percent i
                               Just dim         -> Just $ Inch $ inInch opts dim
                               Nothing          -> Nothing
        let  newattr = (id', cls, dims)
-       entries <- readIORef entriesRef
+       entries <- gets stEntries
        let extension = fromMaybe (takeExtension $ takeWhile (/='?') src)
                            (mbMimeType >>= extensionFromMimeType)
        let newsrc = "Pictures/" ++ show (length entries) <.> extension
        let toLazy = B.fromChunks . (:[])
-       epochtime <- floor `fmap` getPOSIXTime
+       epochtime <- floor `fmap` lift P.getPOSIXTime
        let entry = toEntry newsrc epochtime $ toLazy img
-       modifyIORef entriesRef (entry:)
-       return $ Image newattr lab (newsrc, t)
-transformPicMath _ entriesRef (Math t math) = do
-  entries <- readIORef entriesRef
+       modify $ \st -> st{ stEntries = entry : entries }
+       return $ Image newattr lab (newsrc, t))
+   (\e -> do
+       report $ CouldNotFetchResource src (show e)
+       return $ Emph lab)
+
+transformPicMath _ (Math t math) = do
+  entries <- gets stEntries
   let dt = if t == InlineMath then DisplayInline else DisplayBlock
   case writeMathML dt <$> readTeX math of
        Left  _ -> return $ Math t math
        Right r -> do
          let conf = useShortEmptyTags (const False) defaultConfigPP
          let mathml = ppcTopElement conf r
-         epochtime <- floor `fmap` getPOSIXTime
+         epochtime <- floor `fmap` (lift P.getPOSIXTime)
          let dirname = "Formula-" ++ show (length entries) ++ "/"
          let fname = dirname ++ "content.xml"
          let entry = toEntry fname epochtime (fromStringLazy mathml)
-         modifyIORef entriesRef (entry:)
+         let fname' = dirname ++ "settings.xml"
+         let entry' = toEntry fname' epochtime $ documentSettings (t == InlineMath)
+         modify $ \st -> st{ stEntries = entry' : (entry : entries) }
          return $ RawInline (Format "opendocument") $ render Nothing $
-           inTags False "draw:frame" [("text:anchor-type",
-                                       if t == DisplayMath
-                                          then "paragraph"
-                                          else "as-char")
-                                     ,("style:vertical-pos", "middle")
-                                     ,("style:vertical-rel", "text")] $
+           inTags False "draw:frame" (if t == DisplayMath
+                                      then [("draw:style-name","fr2")
+                                           -- `draw:frame` does not support either
+                                           -- `style:vertical-pos` or `style:vertical-rel`,
+                                           -- therefore those attributes must go into the
+                                           -- `style:style` element
+                                           ,("text:anchor-type","paragraph")]
+                                      else [("draw:style-name","fr1")
+                                           ,("text:anchor-type","as-char")]) $
              selfClosingTag "draw:object" [("xlink:href", dirname)
                                         , ("xlink:type", "simple")
                                         , ("xlink:show", "embed")
                                         , ("xlink:actuate", "onLoad")]
 
-transformPicMath _ _ x = return x
+transformPicMath _ x = return x
+
+documentSettings :: Bool -> B.ByteString
+documentSettings isTextMode = fromStringLazy $ render Nothing
+    $ text "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+    $$
+    (inTags True "office:document-settings"
+      [("xmlns:office","urn:oasis:names:tc:opendocument:xmlns:office:1.0")
+      ,("xmlns:xlink","http://www.w3.org/1999/xlink")
+      ,("xmlns:config","urn:oasis:names:tc:opendocument:xmlns:config:1.0")
+      ,("xmlns:ooo","http://openoffice.org/2004/office")
+      ,("office:version","1.2")] $
+       inTagsSimple "office:settings" $
+         inTags False "config:config-item-set"
+           [("config:name", "ooo:configuration-settings")] $
+           inTags False "config:config-item" [("config:name", "IsTextMode")
+                                             ,("config:type", "boolean")] $
+                                              text $ if isTextMode then "true" else "false")