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, 28 insertions, 27 deletions

diff --git a/src/Text/Pandoc/Readers/Docx/Combine.hs b/src/Text/Pandoc/Readers/Docx/Combine.hs
index 39e0df825..003265e6e 100644
--- a/src/Text/Pandoc/Readers/Docx/Combine.hs
+++ b/src/Text/Pandoc/Readers/Docx/Combine.hs
@@ -1,15 +1,16 @@
-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances,
-    PatternGuards #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE PatternGuards        #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 
 module Text.Pandoc.Readers.Docx.Combine ( smushInlines
                                         , smushBlocks
                                         )
        where
 
-import Text.Pandoc.Builder
 import Data.List
-import Data.Sequence (ViewR(..), ViewL(..), viewl, viewr, (><), (|>))
+import Data.Sequence (ViewL (..), ViewR (..), viewl, viewr, (><), (|>))
 import qualified Data.Sequence as Seq (null)
+import Text.Pandoc.Builder
 
 data Modifier a = Modifier (a -> a)
                 | AttrModifier (Attr -> a -> a) Attr
@@ -35,16 +36,16 @@ spaceOutInlines ils =
       right = case viewr contents of
         (_ :> Space) -> space
         _            -> mempty in
-  (left, (stackInlines fs $ trimInlines . Many $ contents), right)
+  (left, stackInlines fs $ trimInlines . Many $ contents, right)
 
 stackInlines :: [Modifier Inlines] -> Inlines -> Inlines
 stackInlines [] ms = ms
 stackInlines (NullModifier : fs) ms = stackInlines fs ms
-stackInlines ((Modifier f) : fs) ms =
+stackInlines (Modifier f : fs) ms =
   if isEmpty ms
   then stackInlines fs ms
   else f $ stackInlines fs ms
-stackInlines ((AttrModifier f attr) : fs) ms = f attr $ stackInlines fs ms
+stackInlines (AttrModifier f attr : fs) ms = f attr $ stackInlines fs ms
 
 unstackInlines :: Inlines -> ([Modifier Inlines], Inlines)
 unstackInlines ms = case ilModifier ms of
@@ -56,15 +57,15 @@ unstackInlines ms = case ilModifier ms of
 ilModifier :: Inlines -> Modifier Inlines
 ilModifier ils = case viewl (unMany ils) of
   (x :< xs) | Seq.null xs -> case x of
-    (Emph _)        -> Modifier emph
-    (Strong _)      -> Modifier strong
-    (SmallCaps _)   -> Modifier smallcaps
-    (Strikeout _)   -> Modifier strikeout
-    (Superscript _) -> Modifier superscript
-    (Subscript _)   -> Modifier subscript
+    (Emph _)          -> Modifier emph
+    (Strong _)        -> Modifier strong
+    (SmallCaps _)     -> Modifier smallcaps
+    (Strikeout _)     -> Modifier strikeout
+    (Superscript _)   -> Modifier superscript
+    (Subscript _)     -> Modifier subscript
     (Link attr _ tgt) -> Modifier $ linkWith attr (fst tgt) (snd tgt)
-    (Span attr _)   -> AttrModifier spanWith attr
-    _               -> NullModifier
+    (Span attr _)     -> AttrModifier spanWith attr
+    _                 -> NullModifier
   _ -> NullModifier
 
 ilInnards :: Inlines -> Inlines
@@ -78,25 +79,25 @@ ilInnards ils = case viewl (unMany ils) of
     (Subscript lst)   -> fromList lst
     (Link _ lst _)    -> fromList lst
     (Span _ lst)      -> fromList lst
-    _        -> ils
+    _                 -> ils
   _          -> ils
 
 inlinesL :: Inlines -> (Inlines, Inlines)
 inlinesL ils = case viewl $ unMany ils of
   (s :< sq) -> (singleton s, Many sq)
-  _          -> (mempty, ils)
+  _         -> (mempty, ils)
 
 inlinesR :: Inlines -> (Inlines, Inlines)
 inlinesR ils = case viewr $ unMany ils of
   (sq :> s) -> (Many sq, singleton s)
-  _          -> (ils, mempty)
+  _         -> (ils, mempty)
 
 combineInlines :: Inlines -> Inlines -> Inlines
 combineInlines x y =
   let (xs', x') = inlinesR x
       (y', ys') = inlinesL y
   in
-   xs' <> (combineSingletonInlines x' y') <> ys'
+   xs' <> combineSingletonInlines x' y' <> ys'
 
 combineSingletonInlines :: Inlines -> Inlines -> Inlines
 combineSingletonInlines x y =
@@ -113,10 +114,10 @@ combineSingletonInlines x y =
             stackInlines (x_rem_attr ++ y_rem_attr) mempty
           | isEmpty xs ->
             let (sp, y') = spaceOutInlinesL y in
-            (stackInlines x_rem_attr mempty) <> sp <> y'
+            stackInlines x_rem_attr mempty <> sp <> y'
           | isEmpty ys ->
             let (x', sp) = spaceOutInlinesR x in
-            x' <> sp <> (stackInlines y_rem_attr mempty)
+            x' <> sp <> stackInlines y_rem_attr mempty
           | otherwise ->
               let (x', xsp) = spaceOutInlinesR x
                   (ysp, y') = spaceOutInlinesL y
@@ -129,15 +130,15 @@ combineSingletonInlines x y =
 
 combineBlocks :: Blocks -> Blocks -> Blocks
 combineBlocks bs cs
-  | bs' :> (BlockQuote bs'') <- viewr (unMany bs)
-  , (BlockQuote cs'') :< cs' <- viewl (unMany cs) =
-      Many $ (bs' |> (BlockQuote (bs'' <> cs''))) >< cs'
+  | bs' :> BlockQuote bs'' <- viewr (unMany bs)
+  , BlockQuote cs'' :< cs' <- viewl (unMany cs) =
+      Many $ (bs' |> BlockQuote (bs'' <> cs'')) >< cs'
 combineBlocks bs cs = bs <> cs
 
 instance (Monoid a, Eq a) => Eq (Modifier a) where
-  (Modifier f) == (Modifier g) = (f mempty == g mempty)
-  (AttrModifier f attr) == (AttrModifier g attr') = (f attr mempty == g attr' mempty)
-  (NullModifier) == (NullModifier) = True
+  (Modifier f) == (Modifier g) = f mempty == g mempty
+  (AttrModifier f attr) == (AttrModifier g attr') = f attr mempty == g attr' mempty
+  NullModifier == NullModifier = True
   _ == _ = False
 
 isEmpty :: (Monoid a, Eq a) => a -> Bool