{-|
Module      :  Idris.Docstrings
Description : Wrapper around Markdown library.

License     : BSD3
Maintainer  : The Idris Community.
-}

{-# LANGUAGE CPP, DeriveFoldable, DeriveFunctor, DeriveGeneric,
             DeriveTraversable, ScopedTypeVariables #-}
{-# OPTIONS_GHC -fwarn-incomplete-patterns #-}
module Idris.Docstrings (
    Docstring(..), Block(..), Inline(..), parseDocstring, renderDocstring
  , emptyDocstring, nullDocstring, noDocs, overview, containsText
  , renderHtml, annotCode, DocTerm(..), renderDocTerm, checkDocstring
  ) where

import Idris.Core.TT (Err, Name, OutputAnnotation(..), Term, TextFormatting(..))

import Util.Pretty

#if (MIN_VERSION_base(4,11,0))
import Prelude hiding ((<$>), (<>))
#else
import Prelude hiding ((<$>))
#endif
import qualified Cheapskate as C
import Cheapskate.Html (renderDoc)
import qualified Cheapskate.Types as CT
import qualified Data.Foldable as F
import qualified Data.Sequence as S
import qualified Data.Text as T
import GHC.Generics (Generic)
import Text.Blaze.Html (Html)

-- | The various kinds of code samples that can be embedded in docs
data DocTerm = Unchecked
             | Checked Term
             | Example Term
             | Failing Err
  deriving (Int -> DocTerm -> ShowS
[DocTerm] -> ShowS
DocTerm -> String
(Int -> DocTerm -> ShowS)
-> (DocTerm -> String) -> ([DocTerm] -> ShowS) -> Show DocTerm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DocTerm -> ShowS
showsPrec :: Int -> DocTerm -> ShowS
$cshow :: DocTerm -> String
show :: DocTerm -> String
$cshowList :: [DocTerm] -> ShowS
showList :: [DocTerm] -> ShowS
Show, (forall x. DocTerm -> Rep DocTerm x)
-> (forall x. Rep DocTerm x -> DocTerm) -> Generic DocTerm
forall x. Rep DocTerm x -> DocTerm
forall x. DocTerm -> Rep DocTerm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DocTerm -> Rep DocTerm x
from :: forall x. DocTerm -> Rep DocTerm x
$cto :: forall x. Rep DocTerm x -> DocTerm
to :: forall x. Rep DocTerm x -> DocTerm
Generic)

-- | Render a term in the documentation
renderDocTerm :: (Term -> Doc OutputAnnotation) -> (Term -> Term) -> DocTerm -> String -> Doc OutputAnnotation
renderDocTerm :: (Term -> Doc OutputAnnotation)
-> (Term -> Term) -> DocTerm -> String -> Doc OutputAnnotation
renderDocTerm Term -> Doc OutputAnnotation
pp Term -> Term
norm DocTerm
Unchecked     String
src = String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
src
renderDocTerm Term -> Doc OutputAnnotation
pp Term -> Term
norm (Checked Term
tm)  String
src = Term -> Doc OutputAnnotation
pp Term
tm
renderDocTerm Term -> Doc OutputAnnotation
pp Term -> Term
norm (Example Term
tm)  String
src = Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a
align (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$
                                                String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
">" Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a
align (Term -> Doc OutputAnnotation
pp Term
tm) Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<$>
                                                Term -> Doc OutputAnnotation
pp (Term -> Term
norm Term
tm)
renderDocTerm Term -> Doc OutputAnnotation
pp Term -> Term
norm (Failing Err
err) String
src = OutputAnnotation -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. a -> Doc a -> Doc a
annotate (Err -> OutputAnnotation
AnnErr Err
err) (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
src

-- | Representation of Idris's inline documentation. The type paramter
-- represents the type of terms that are associated with code blocks.
data Docstring a = DocString CT.Options (Blocks a)
  deriving (Int -> Docstring a -> ShowS
[Docstring a] -> ShowS
Docstring a -> String
(Int -> Docstring a -> ShowS)
-> (Docstring a -> String)
-> ([Docstring a] -> ShowS)
-> Show (Docstring a)
forall a. Show a => Int -> Docstring a -> ShowS
forall a. Show a => [Docstring a] -> ShowS
forall a. Show a => Docstring a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Docstring a -> ShowS
showsPrec :: Int -> Docstring a -> ShowS
$cshow :: forall a. Show a => Docstring a -> String
show :: Docstring a -> String
$cshowList :: forall a. Show a => [Docstring a] -> ShowS
showList :: [Docstring a] -> ShowS
Show, (forall a b. (a -> b) -> Docstring a -> Docstring b)
-> (forall a b. a -> Docstring b -> Docstring a)
-> Functor Docstring
forall a b. a -> Docstring b -> Docstring a
forall a b. (a -> b) -> Docstring a -> Docstring b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Docstring a -> Docstring b
fmap :: forall a b. (a -> b) -> Docstring a -> Docstring b
$c<$ :: forall a b. a -> Docstring b -> Docstring a
<$ :: forall a b. a -> Docstring b -> Docstring a
Functor, (forall m. Monoid m => Docstring m -> m)
-> (forall m a. Monoid m => (a -> m) -> Docstring a -> m)
-> (forall m a. Monoid m => (a -> m) -> Docstring a -> m)
-> (forall a b. (a -> b -> b) -> b -> Docstring a -> b)
-> (forall a b. (a -> b -> b) -> b -> Docstring a -> b)
-> (forall b a. (b -> a -> b) -> b -> Docstring a -> b)
-> (forall b a. (b -> a -> b) -> b -> Docstring a -> b)
-> (forall a. (a -> a -> a) -> Docstring a -> a)
-> (forall a. (a -> a -> a) -> Docstring a -> a)
-> (forall a. Docstring a -> [a])
-> (forall a. Docstring a -> Bool)
-> (forall a. Docstring a -> Int)
-> (forall a. Eq a => a -> Docstring a -> Bool)
-> (forall a. Ord a => Docstring a -> a)
-> (forall a. Ord a => Docstring a -> a)
-> (forall a. Num a => Docstring a -> a)
-> (forall a. Num a => Docstring a -> a)
-> Foldable Docstring
forall a. Eq a => a -> Docstring a -> Bool
forall a. Num a => Docstring a -> a
forall a. Ord a => Docstring a -> a
forall m. Monoid m => Docstring m -> m
forall a. Docstring a -> Bool
forall a. Docstring a -> Int
forall a. Docstring a -> [a]
forall a. (a -> a -> a) -> Docstring a -> a
forall m a. Monoid m => (a -> m) -> Docstring a -> m
forall b a. (b -> a -> b) -> b -> Docstring a -> b
forall a b. (a -> b -> b) -> b -> Docstring a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Docstring m -> m
fold :: forall m. Monoid m => Docstring m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Docstring a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Docstring a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Docstring a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Docstring a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Docstring a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Docstring a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Docstring a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Docstring a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Docstring a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Docstring a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Docstring a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Docstring a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Docstring a -> a
foldr1 :: forall a. (a -> a -> a) -> Docstring a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Docstring a -> a
foldl1 :: forall a. (a -> a -> a) -> Docstring a -> a
$ctoList :: forall a. Docstring a -> [a]
toList :: forall a. Docstring a -> [a]
$cnull :: forall a. Docstring a -> Bool
null :: forall a. Docstring a -> Bool
$clength :: forall a. Docstring a -> Int
length :: forall a. Docstring a -> Int
$celem :: forall a. Eq a => a -> Docstring a -> Bool
elem :: forall a. Eq a => a -> Docstring a -> Bool
$cmaximum :: forall a. Ord a => Docstring a -> a
maximum :: forall a. Ord a => Docstring a -> a
$cminimum :: forall a. Ord a => Docstring a -> a
minimum :: forall a. Ord a => Docstring a -> a
$csum :: forall a. Num a => Docstring a -> a
sum :: forall a. Num a => Docstring a -> a
$cproduct :: forall a. Num a => Docstring a -> a
product :: forall a. Num a => Docstring a -> a
Foldable, Functor Docstring
Foldable Docstring
(Functor Docstring, Foldable Docstring) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Docstring a -> f (Docstring b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Docstring (f a) -> f (Docstring a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Docstring a -> m (Docstring b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Docstring (m a) -> m (Docstring a))
-> Traversable Docstring
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Docstring (m a) -> m (Docstring a)
forall (f :: * -> *) a.
Applicative f =>
Docstring (f a) -> f (Docstring a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Docstring a -> m (Docstring b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Docstring a -> f (Docstring b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Docstring a -> f (Docstring b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Docstring a -> f (Docstring b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Docstring (f a) -> f (Docstring a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Docstring (f a) -> f (Docstring a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Docstring a -> m (Docstring b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Docstring a -> m (Docstring b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Docstring (m a) -> m (Docstring a)
sequence :: forall (m :: * -> *) a.
Monad m =>
Docstring (m a) -> m (Docstring a)
Traversable, (forall x. Docstring a -> Rep (Docstring a) x)
-> (forall x. Rep (Docstring a) x -> Docstring a)
-> Generic (Docstring a)
forall x. Rep (Docstring a) x -> Docstring a
forall x. Docstring a -> Rep (Docstring a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Docstring a) x -> Docstring a
forall a x. Docstring a -> Rep (Docstring a) x
$cfrom :: forall a x. Docstring a -> Rep (Docstring a) x
from :: forall x. Docstring a -> Rep (Docstring a) x
$cto :: forall a x. Rep (Docstring a) x -> Docstring a
to :: forall x. Rep (Docstring a) x -> Docstring a
Generic)

type Blocks a = S.Seq (Block a)

-- | Block-level elements.
data Block a = Para (Inlines a)
             | Header Int (Inlines a)
             | Blockquote (Blocks a)
             | List Bool CT.ListType [Blocks a]
             | CodeBlock CT.CodeAttr T.Text a
             | HtmlBlock T.Text
             | HRule
             deriving (Int -> Block a -> ShowS
[Block a] -> ShowS
Block a -> String
(Int -> Block a -> ShowS)
-> (Block a -> String) -> ([Block a] -> ShowS) -> Show (Block a)
forall a. Show a => Int -> Block a -> ShowS
forall a. Show a => [Block a] -> ShowS
forall a. Show a => Block a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Block a -> ShowS
showsPrec :: Int -> Block a -> ShowS
$cshow :: forall a. Show a => Block a -> String
show :: Block a -> String
$cshowList :: forall a. Show a => [Block a] -> ShowS
showList :: [Block a] -> ShowS
Show, (forall a b. (a -> b) -> Block a -> Block b)
-> (forall a b. a -> Block b -> Block a) -> Functor Block
forall a b. a -> Block b -> Block a
forall a b. (a -> b) -> Block a -> Block b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Block a -> Block b
fmap :: forall a b. (a -> b) -> Block a -> Block b
$c<$ :: forall a b. a -> Block b -> Block a
<$ :: forall a b. a -> Block b -> Block a
Functor, (forall m. Monoid m => Block m -> m)
-> (forall m a. Monoid m => (a -> m) -> Block a -> m)
-> (forall m a. Monoid m => (a -> m) -> Block a -> m)
-> (forall a b. (a -> b -> b) -> b -> Block a -> b)
-> (forall a b. (a -> b -> b) -> b -> Block a -> b)
-> (forall b a. (b -> a -> b) -> b -> Block a -> b)
-> (forall b a. (b -> a -> b) -> b -> Block a -> b)
-> (forall a. (a -> a -> a) -> Block a -> a)
-> (forall a. (a -> a -> a) -> Block a -> a)
-> (forall a. Block a -> [a])
-> (forall a. Block a -> Bool)
-> (forall a. Block a -> Int)
-> (forall a. Eq a => a -> Block a -> Bool)
-> (forall a. Ord a => Block a -> a)
-> (forall a. Ord a => Block a -> a)
-> (forall a. Num a => Block a -> a)
-> (forall a. Num a => Block a -> a)
-> Foldable Block
forall a. Eq a => a -> Block a -> Bool
forall a. Num a => Block a -> a
forall a. Ord a => Block a -> a
forall m. Monoid m => Block m -> m
forall a. Block a -> Bool
forall a. Block a -> Int
forall a. Block a -> [a]
forall a. (a -> a -> a) -> Block a -> a
forall m a. Monoid m => (a -> m) -> Block a -> m
forall b a. (b -> a -> b) -> b -> Block a -> b
forall a b. (a -> b -> b) -> b -> Block a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Block m -> m
fold :: forall m. Monoid m => Block m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Block a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Block a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Block a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Block a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Block a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Block a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Block a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Block a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Block a -> a
foldr1 :: forall a. (a -> a -> a) -> Block a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Block a -> a
foldl1 :: forall a. (a -> a -> a) -> Block a -> a
$ctoList :: forall a. Block a -> [a]
toList :: forall a. Block a -> [a]
$cnull :: forall a. Block a -> Bool
null :: forall a. Block a -> Bool
$clength :: forall a. Block a -> Int
length :: forall a. Block a -> Int
$celem :: forall a. Eq a => a -> Block a -> Bool
elem :: forall a. Eq a => a -> Block a -> Bool
$cmaximum :: forall a. Ord a => Block a -> a
maximum :: forall a. Ord a => Block a -> a
$cminimum :: forall a. Ord a => Block a -> a
minimum :: forall a. Ord a => Block a -> a
$csum :: forall a. Num a => Block a -> a
sum :: forall a. Num a => Block a -> a
$cproduct :: forall a. Num a => Block a -> a
product :: forall a. Num a => Block a -> a
Foldable, Functor Block
Foldable Block
(Functor Block, Foldable Block) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Block a -> f (Block b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Block (f a) -> f (Block a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Block a -> m (Block b))
-> (forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a))
-> Traversable Block
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a)
forall (f :: * -> *) a. Applicative f => Block (f a) -> f (Block a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Block a -> m (Block b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Block a -> f (Block b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Block a -> f (Block b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Block a -> f (Block b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Block (f a) -> f (Block a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Block (f a) -> f (Block a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Block a -> m (Block b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Block a -> m (Block b)
$csequence :: forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a)
sequence :: forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a)
Traversable, (forall x. Block a -> Rep (Block a) x)
-> (forall x. Rep (Block a) x -> Block a) -> Generic (Block a)
forall x. Rep (Block a) x -> Block a
forall x. Block a -> Rep (Block a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Block a) x -> Block a
forall a x. Block a -> Rep (Block a) x
$cfrom :: forall a x. Block a -> Rep (Block a) x
from :: forall x. Block a -> Rep (Block a) x
$cto :: forall a x. Rep (Block a) x -> Block a
to :: forall x. Rep (Block a) x -> Block a
Generic)

data Inline a = Str T.Text
              | Space
              | SoftBreak
              | LineBreak
              | Emph (Inlines a)
              | Strong (Inlines a)
              | Code T.Text a
              | Link (Inlines a) T.Text T.Text
              | Image (Inlines a) T.Text T.Text
              | Entity T.Text
              | RawHtml T.Text
              deriving (Int -> Inline a -> ShowS
[Inline a] -> ShowS
Inline a -> String
(Int -> Inline a -> ShowS)
-> (Inline a -> String) -> ([Inline a] -> ShowS) -> Show (Inline a)
forall a. Show a => Int -> Inline a -> ShowS
forall a. Show a => [Inline a] -> ShowS
forall a. Show a => Inline a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Inline a -> ShowS
showsPrec :: Int -> Inline a -> ShowS
$cshow :: forall a. Show a => Inline a -> String
show :: Inline a -> String
$cshowList :: forall a. Show a => [Inline a] -> ShowS
showList :: [Inline a] -> ShowS
Show, (forall a b. (a -> b) -> Inline a -> Inline b)
-> (forall a b. a -> Inline b -> Inline a) -> Functor Inline
forall a b. a -> Inline b -> Inline a
forall a b. (a -> b) -> Inline a -> Inline b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Inline a -> Inline b
fmap :: forall a b. (a -> b) -> Inline a -> Inline b
$c<$ :: forall a b. a -> Inline b -> Inline a
<$ :: forall a b. a -> Inline b -> Inline a
Functor, (forall m. Monoid m => Inline m -> m)
-> (forall m a. Monoid m => (a -> m) -> Inline a -> m)
-> (forall m a. Monoid m => (a -> m) -> Inline a -> m)
-> (forall a b. (a -> b -> b) -> b -> Inline a -> b)
-> (forall a b. (a -> b -> b) -> b -> Inline a -> b)
-> (forall b a. (b -> a -> b) -> b -> Inline a -> b)
-> (forall b a. (b -> a -> b) -> b -> Inline a -> b)
-> (forall a. (a -> a -> a) -> Inline a -> a)
-> (forall a. (a -> a -> a) -> Inline a -> a)
-> (forall a. Inline a -> [a])
-> (forall a. Inline a -> Bool)
-> (forall a. Inline a -> Int)
-> (forall a. Eq a => a -> Inline a -> Bool)
-> (forall a. Ord a => Inline a -> a)
-> (forall a. Ord a => Inline a -> a)
-> (forall a. Num a => Inline a -> a)
-> (forall a. Num a => Inline a -> a)
-> Foldable Inline
forall a. Eq a => a -> Inline a -> Bool
forall a. Num a => Inline a -> a
forall a. Ord a => Inline a -> a
forall m. Monoid m => Inline m -> m
forall a. Inline a -> Bool
forall a. Inline a -> Int
forall a. Inline a -> [a]
forall a. (a -> a -> a) -> Inline a -> a
forall m a. Monoid m => (a -> m) -> Inline a -> m
forall b a. (b -> a -> b) -> b -> Inline a -> b
forall a b. (a -> b -> b) -> b -> Inline a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Inline m -> m
fold :: forall m. Monoid m => Inline m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Inline a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Inline a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Inline a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Inline a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Inline a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Inline a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Inline a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Inline a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Inline a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Inline a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Inline a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Inline a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Inline a -> a
foldr1 :: forall a. (a -> a -> a) -> Inline a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Inline a -> a
foldl1 :: forall a. (a -> a -> a) -> Inline a -> a
$ctoList :: forall a. Inline a -> [a]
toList :: forall a. Inline a -> [a]
$cnull :: forall a. Inline a -> Bool
null :: forall a. Inline a -> Bool
$clength :: forall a. Inline a -> Int
length :: forall a. Inline a -> Int
$celem :: forall a. Eq a => a -> Inline a -> Bool
elem :: forall a. Eq a => a -> Inline a -> Bool
$cmaximum :: forall a. Ord a => Inline a -> a
maximum :: forall a. Ord a => Inline a -> a
$cminimum :: forall a. Ord a => Inline a -> a
minimum :: forall a. Ord a => Inline a -> a
$csum :: forall a. Num a => Inline a -> a
sum :: forall a. Num a => Inline a -> a
$cproduct :: forall a. Num a => Inline a -> a
product :: forall a. Num a => Inline a -> a
Foldable, Functor Inline
Foldable Inline
(Functor Inline, Foldable Inline) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Inline a -> f (Inline b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Inline (f a) -> f (Inline a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Inline a -> m (Inline b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Inline (m a) -> m (Inline a))
-> Traversable Inline
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Inline (m a) -> m (Inline a)
forall (f :: * -> *) a.
Applicative f =>
Inline (f a) -> f (Inline a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Inline a -> m (Inline b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Inline a -> f (Inline b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Inline a -> f (Inline b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Inline a -> f (Inline b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Inline (f a) -> f (Inline a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Inline (f a) -> f (Inline a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Inline a -> m (Inline b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Inline a -> m (Inline b)
$csequence :: forall (m :: * -> *) a. Monad m => Inline (m a) -> m (Inline a)
sequence :: forall (m :: * -> *) a. Monad m => Inline (m a) -> m (Inline a)
Traversable, (forall x. Inline a -> Rep (Inline a) x)
-> (forall x. Rep (Inline a) x -> Inline a) -> Generic (Inline a)
forall x. Rep (Inline a) x -> Inline a
forall x. Inline a -> Rep (Inline a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Inline a) x -> Inline a
forall a x. Inline a -> Rep (Inline a) x
$cfrom :: forall a x. Inline a -> Rep (Inline a) x
from :: forall x. Inline a -> Rep (Inline a) x
$cto :: forall a x. Rep (Inline a) x -> Inline a
to :: forall x. Rep (Inline a) x -> Inline a
Generic)

type Inlines a = S.Seq (Inline a)


-- | Run some kind of processing step over code in a Docstring. The code
-- processor gets the language and annotations as parameters, along with the
-- source and the original annotation.
checkDocstring :: forall a b. (String -> [String] -> String -> a -> b) -> Docstring a -> Docstring b
checkDocstring :: forall a b.
(String -> [String] -> String -> a -> b)
-> Docstring a -> Docstring b
checkDocstring String -> [String] -> String -> a -> b
f (DocString Options
opts Blocks a
blocks) = Options -> Blocks b -> Docstring b
forall a. Options -> Blocks a -> Docstring a
DocString Options
opts ((Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Block a -> Block b
checkBlock String -> [String] -> String -> a -> b
f) Blocks a
blocks)
  where checkBlock :: (String -> [String] -> String -> a -> b) -> Block a -> Block b
        checkBlock :: (String -> [String] -> String -> a -> b) -> Block a -> Block b
checkBlock String -> [String] -> String -> a -> b
f (Para Inlines a
inlines)           = Inlines b -> Block b
forall a. Inlines a -> Block a
Para ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
inlines)
        checkBlock String -> [String] -> String -> a -> b
f (Header Int
i Inlines a
inlines)       = Int -> Inlines b -> Block b
forall a. Int -> Inlines a -> Block a
Header Int
i ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
inlines)
        checkBlock String -> [String] -> String -> a -> b
f (Blockquote Blocks a
bs)          = Blocks b -> Block b
forall a. Blocks a -> Block a
Blockquote ((Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Block a -> Block b
checkBlock String -> [String] -> String -> a -> b
f) Blocks a
bs)
        checkBlock String -> [String] -> String -> a -> b
f (List Bool
b ListType
t [Blocks a]
blocks)        = Bool -> ListType -> [Blocks b] -> Block b
forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t ((Blocks a -> Blocks b) -> [Blocks a] -> [Blocks b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Block a -> Block b
checkBlock String -> [String] -> String -> a -> b
f)) [Blocks a]
blocks)
        checkBlock String -> [String] -> String -> a -> b
f (CodeBlock CodeAttr
attrs Text
src a
tm) = CodeAttr -> Text -> b -> Block b
forall a. CodeAttr -> Text -> a -> Block a
CodeBlock CodeAttr
attrs Text
src
                                                          (String -> [String] -> String -> a -> b
f (Text -> String
T.unpack (Text -> String) -> Text -> String
forall a b. (a -> b) -> a -> b
$ CodeAttr -> Text
CT.codeLang CodeAttr
attrs)
                                                             (String -> [String]
words (String -> [String]) -> (Text -> String) -> Text -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack (Text -> [String]) -> Text -> [String]
forall a b. (a -> b) -> a -> b
$ CodeAttr -> Text
CT.codeInfo CodeAttr
attrs)
                                                             (Text -> String
T.unpack Text
src)
                                                             a
tm)
        checkBlock String -> [String] -> String -> a -> b
f (HtmlBlock Text
src)          = Text -> Block b
forall a. Text -> Block a
HtmlBlock Text
src
        checkBlock String -> [String] -> String -> a -> b
f Block a
HRule                    = Block b
forall a. Block a
HRule

        checkInline :: (String -> [String] -> String -> a -> b) -> Inline a -> Inline b
        checkInline :: (String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f (Str Text
txt)            = Text -> Inline b
forall a. Text -> Inline a
Str Text
txt
        checkInline String -> [String] -> String -> a -> b
f Inline a
Space                = Inline b
forall a. Inline a
Space
        checkInline String -> [String] -> String -> a -> b
f Inline a
SoftBreak            = Inline b
forall a. Inline a
SoftBreak
        checkInline String -> [String] -> String -> a -> b
f Inline a
LineBreak            = Inline b
forall a. Inline a
LineBreak
        checkInline String -> [String] -> String -> a -> b
f (Emph Inlines a
is)            = Inlines b -> Inline b
forall a. Inlines a -> Inline a
Emph ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
is)
        checkInline String -> [String] -> String -> a -> b
f (Strong Inlines a
is)          = Inlines b -> Inline b
forall a. Inlines a -> Inline a
Strong ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
is)
        checkInline String -> [String] -> String -> a -> b
f (Code Text
src a
x)         = Text -> b -> Inline b
forall a. Text -> a -> Inline a
Code Text
src (String -> [String] -> String -> a -> b
f String
"" [] (Text -> String
T.unpack Text
src) a
x)
        checkInline String -> [String] -> String -> a -> b
f (Link Inlines a
is Text
url Text
title)  = Inlines b -> Text -> Text -> Inline b
forall a. Inlines a -> Text -> Text -> Inline a
Link ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
is) Text
url Text
title
        checkInline String -> [String] -> String -> a -> b
f (Image Inlines a
is Text
url Text
title) = Inlines b -> Text -> Text -> Inline b
forall a. Inlines a -> Text -> Text -> Inline a
Image ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String -> [String] -> String -> a -> b) -> Inline a -> Inline b
checkInline String -> [String] -> String -> a -> b
f) Inlines a
is) Text
url Text
title
        checkInline String -> [String] -> String -> a -> b
f (Entity Text
txt)         = Text -> Inline b
forall a. Text -> Inline a
Entity Text
txt
        checkInline String -> [String] -> String -> a -> b
f (RawHtml Text
src)        = Text -> Inline b
forall a. Text -> Inline a
RawHtml Text
src

-- | Construct a docstring from a Text that contains Markdown-formatted docs
parseDocstring :: T.Text -> Docstring ()
parseDocstring :: Text -> Docstring ()
parseDocstring = Doc -> Docstring ()
toDocstring (Doc -> Docstring ()) -> (Text -> Doc) -> Text -> Docstring ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Options -> Text -> Doc
C.markdown Options
options
  where toDocstring :: CT.Doc -> Docstring ()
        toDocstring :: Doc -> Docstring ()
toDocstring (CT.Doc Options
opts Blocks
blocks) = Options -> Blocks () -> Docstring ()
forall a. Options -> Blocks a -> Docstring a
DocString Options
opts ((Block -> Block ()) -> Blocks -> Blocks ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> Block ()
toBlock Blocks
blocks)

        toBlock :: CT.Block -> Block ()
        toBlock :: Block -> Block ()
toBlock (CT.Para Inlines
inlines)         = Inlines () -> Block ()
forall a. Inlines a -> Block a
Para ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
inlines)
        toBlock (CT.Header Int
i Inlines
inlines)     = Int -> Inlines () -> Block ()
forall a. Int -> Inlines a -> Block a
Header Int
i ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
inlines)
        toBlock (CT.Blockquote Blocks
blocks)    = Blocks () -> Block ()
forall a. Blocks a -> Block a
Blockquote ((Block -> Block ()) -> Blocks -> Blocks ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> Block ()
toBlock Blocks
blocks)
        toBlock (CT.List Bool
b ListType
t [Blocks]
blocks)      = Bool -> ListType -> [Blocks ()] -> Block ()
forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t ((Blocks -> Blocks ()) -> [Blocks] -> [Blocks ()]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Block -> Block ()) -> Blocks -> Blocks ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block -> Block ()
toBlock) [Blocks]
blocks)
        toBlock (CT.CodeBlock CodeAttr
attrs Text
text) = CodeAttr -> Text -> () -> Block ()
forall a. CodeAttr -> Text -> a -> Block a
CodeBlock CodeAttr
attrs Text
text ()
        toBlock (CT.HtmlBlock Text
src)        = Text -> Block ()
forall a. Text -> Block a
HtmlBlock Text
src
        toBlock Block
CT.HRule                  = Block ()
forall a. Block a
HRule

        toInline :: CT.Inline -> Inline ()
        toInline :: Inline -> Inline ()
toInline (CT.Str Text
t)              = Text -> Inline ()
forall a. Text -> Inline a
Str Text
t
        toInline Inline
CT.Space                = Inline ()
forall a. Inline a
Space
        toInline Inline
CT.SoftBreak            = Inline ()
forall a. Inline a
SoftBreak
        toInline Inline
CT.LineBreak            = Inline ()
forall a. Inline a
LineBreak
        toInline (CT.Emph Inlines
is)            = Inlines () -> Inline ()
forall a. Inlines a -> Inline a
Emph ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is)
        toInline (CT.Strong Inlines
is)          = Inlines () -> Inline ()
forall a. Inlines a -> Inline a
Strong ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is)
        toInline (CT.Code Text
src)           = Text -> () -> Inline ()
forall a. Text -> a -> Inline a
Code Text
src ()
        toInline (CT.Link Inlines
is Text
url Text
title)  = Inlines () -> Text -> Text -> Inline ()
forall a. Inlines a -> Text -> Text -> Inline a
Link ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is) Text
url Text
title
        toInline (CT.Image Inlines
is Text
url Text
title) = Inlines () -> Text -> Text -> Inline ()
forall a. Inlines a -> Text -> Text -> Inline a
Image ((Inline -> Inline ()) -> Inlines -> Inlines ()
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is) Text
url Text
title
        toInline (CT.Entity Text
txt)         = Text -> Inline ()
forall a. Text -> Inline a
Entity Text
txt
        toInline (CT.RawHtml Text
src)        = Text -> Inline ()
forall a. Text -> Inline a
RawHtml Text
src


options :: Options
options = CT.Options { sanitize :: Bool
CT.sanitize = Bool
True
                     , allowRawHtml :: Bool
CT.allowRawHtml = Bool
False
                     , preserveHardBreaks :: Bool
CT.preserveHardBreaks = Bool
True
                     , debug :: Bool
CT.debug = Bool
False
                     }

-- | Convert a docstring to be shown by the pretty-printer
renderDocstring :: (a -> String -> Doc OutputAnnotation) -> Docstring a -> Doc OutputAnnotation
renderDocstring :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Docstring a -> Doc OutputAnnotation
renderDocstring a -> String -> Doc OutputAnnotation
pp (DocString Options
_ Blocks a
blocks) = (a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
renderBlocks a -> String -> Doc OutputAnnotation
pp Blocks a
blocks

-- | Construct a docstring consisting of the first block-level element of the
-- argument docstring, for use in summaries.
overview :: Docstring a -> Docstring a
overview :: forall a. Docstring a -> Docstring a
overview (DocString Options
opts Blocks a
blocks) = Options -> Blocks a -> Docstring a
forall a. Options -> Blocks a -> Docstring a
DocString Options
opts (Int -> Blocks a -> Blocks a
forall a. Int -> Seq a -> Seq a
S.take Int
1 Blocks a
blocks)

renderBlocks :: (a -> String -> Doc OutputAnnotation)
             -> Blocks a -> Doc OutputAnnotation
renderBlocks :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
renderBlocks a -> String -> Doc OutputAnnotation
pp Blocks a
blocks  | Blocks a -> Int
forall a. Seq a -> Int
S.length Blocks a
blocks Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1  = (Doc OutputAnnotation
 -> Doc OutputAnnotation -> Doc OutputAnnotation)
-> Seq (Doc OutputAnnotation) -> Doc OutputAnnotation
forall a. (a -> a -> a) -> Seq a -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
F.foldr1 (\Doc OutputAnnotation
b1 Doc OutputAnnotation
b2 -> Doc OutputAnnotation
b1 Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
forall a. Doc a
line Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
forall a. Doc a
line Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
b2) (Seq (Doc OutputAnnotation) -> Doc OutputAnnotation)
-> Seq (Doc OutputAnnotation) -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$
                                                  (Block a -> Doc OutputAnnotation)
-> Blocks a -> Seq (Doc OutputAnnotation)
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
renderBlock a -> String -> Doc OutputAnnotation
pp) Blocks a
blocks
                        | Blocks a -> Int
forall a. Seq a -> Int
S.length Blocks a
blocks Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = (a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
renderBlock a -> String -> Doc OutputAnnotation
pp (Blocks a -> Int -> Block a
forall a. Seq a -> Int -> a
S.index Blocks a
blocks Int
0)
                        | Bool
otherwise            = Doc OutputAnnotation
forall a. Doc a
empty

renderBlock :: (a -> String -> Doc OutputAnnotation)
            -> Block a -> Doc OutputAnnotation
renderBlock :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
renderBlock a -> String -> Doc OutputAnnotation
pp (Para Inlines a
inlines) = (a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
inlines
renderBlock a -> String -> Doc OutputAnnotation
pp (Header Int
lvl Inlines a
inlines) = (a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
inlines Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a
parens (String -> Doc OutputAnnotation
forall a. String -> Doc a
text (Int -> String
forall a. Show a => a -> String
show Int
lvl))
renderBlock a -> String -> Doc OutputAnnotation
pp (Blockquote Blocks a
blocks) = Int -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Int -> Doc a -> Doc a
indent Int
8 (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ (a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
renderBlocks a -> String -> Doc OutputAnnotation
pp Blocks a
blocks
renderBlock a -> String -> Doc OutputAnnotation
pp (List Bool
b ListType
ty [Blocks a]
blockss) = (a -> String -> Doc OutputAnnotation)
-> Bool -> ListType -> [Blocks a] -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Bool -> ListType -> [Blocks a] -> Doc OutputAnnotation
renderList a -> String -> Doc OutputAnnotation
pp Bool
b ListType
ty [Blocks a]
blockss
renderBlock a -> String -> Doc OutputAnnotation
pp (CodeBlock CodeAttr
attr Text
src a
tm) = Int -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Int -> Doc a -> Doc a
indent Int
4 (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ a -> String -> Doc OutputAnnotation
pp a
tm (Text -> String
T.unpack Text
src)
renderBlock a -> String -> Doc OutputAnnotation
pp (HtmlBlock Text
txt) = String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
"<html block>" -- TODO
renderBlock a -> String -> Doc OutputAnnotation
pp Block a
HRule = String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
"----------------------"

renderList :: (a -> String -> Doc OutputAnnotation)
           -> Bool -> CT.ListType -> [Blocks a] -> Doc OutputAnnotation
renderList :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Bool -> ListType -> [Blocks a] -> Doc OutputAnnotation
renderList a -> String -> Doc OutputAnnotation
pp Bool
b (CT.Bullet Char
c) [Blocks a]
blockss = [Doc OutputAnnotation] -> Doc OutputAnnotation
forall a. [Doc a] -> Doc a
vsep ([Doc OutputAnnotation] -> Doc OutputAnnotation)
-> [Doc OutputAnnotation] -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ (Blocks a -> Doc OutputAnnotation)
-> [Blocks a] -> [Doc OutputAnnotation]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Int -> Doc a -> Doc a
hang Int
4 (Doc OutputAnnotation -> Doc OutputAnnotation)
-> (Blocks a -> Doc OutputAnnotation)
-> Blocks a
-> Doc OutputAnnotation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Doc OutputAnnotation
forall a. Char -> Doc a
char Char
c Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<+>) (Doc OutputAnnotation -> Doc OutputAnnotation)
-> (Blocks a -> Doc OutputAnnotation)
-> Blocks a
-> Doc OutputAnnotation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
renderBlocks a -> String -> Doc OutputAnnotation
pp) [Blocks a]
blockss
renderList a -> String -> Doc OutputAnnotation
pp Bool
b (CT.Numbered NumWrapper
nw Int
i) [Blocks a]
blockss =
  [Doc OutputAnnotation] -> Doc OutputAnnotation
forall a. [Doc a] -> Doc a
vsep ([Doc OutputAnnotation] -> Doc OutputAnnotation)
-> [Doc OutputAnnotation] -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$
  (Int
 -> Doc OutputAnnotation
 -> Doc OutputAnnotation
 -> Doc OutputAnnotation)
-> [Int]
-> [Doc OutputAnnotation]
-> [Doc OutputAnnotation]
-> [Doc OutputAnnotation]
forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 (\Int
n Doc OutputAnnotation
p Doc OutputAnnotation
txt -> Int -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Int -> Doc a -> Doc a
hang Int
4 (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ String -> Doc OutputAnnotation
forall a. String -> Doc a
text (Int -> String
forall a. Show a => a -> String
show Int
n) Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
p Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation
txt)
           [Int
i..] (Doc OutputAnnotation -> [Doc OutputAnnotation]
forall a. a -> [a]
repeat Doc OutputAnnotation
forall a. Doc a
punc) ((Blocks a -> Doc OutputAnnotation)
-> [Blocks a] -> [Doc OutputAnnotation]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Blocks a -> Doc OutputAnnotation
renderBlocks a -> String -> Doc OutputAnnotation
pp) [Blocks a]
blockss)
  where punc :: Doc a
punc = case NumWrapper
nw of
                 NumWrapper
CT.PeriodFollowing -> Char -> Doc a
forall a. Char -> Doc a
char Char
'.'
                 NumWrapper
CT.ParenFollowing  -> Char -> Doc a
forall a. Char -> Doc a
char Char
'('

renderInlines :: (a -> String -> Doc OutputAnnotation) -> Inlines a -> Doc OutputAnnotation
renderInlines :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp = (Doc OutputAnnotation
 -> Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation
-> Seq (Doc OutputAnnotation)
-> Doc OutputAnnotation
forall a b. (a -> b -> b) -> b -> Seq a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr Doc OutputAnnotation
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. Doc a -> Doc a -> Doc a
(<>) Doc OutputAnnotation
forall a. Doc a
empty (Seq (Doc OutputAnnotation) -> Doc OutputAnnotation)
-> (Inlines a -> Seq (Doc OutputAnnotation))
-> Inlines a
-> Doc OutputAnnotation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline a -> Doc OutputAnnotation)
-> Inlines a -> Seq (Doc OutputAnnotation)
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> String -> Doc OutputAnnotation)
-> Inline a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inline a -> Doc OutputAnnotation
renderInline a -> String -> Doc OutputAnnotation
pp)

renderInline :: (a -> String -> Doc OutputAnnotation) -> Inline a -> Doc OutputAnnotation
renderInline :: forall a.
(a -> String -> Doc OutputAnnotation)
-> Inline a -> Doc OutputAnnotation
renderInline a -> String -> Doc OutputAnnotation
pp (Str Text
s) = String -> Doc OutputAnnotation
forall a. String -> Doc a
text (String -> Doc OutputAnnotation) -> String -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
s
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
Space = Doc OutputAnnotation
forall a. Doc a
softline
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
SoftBreak = Doc OutputAnnotation
forall a. Doc a
softline
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
LineBreak = Doc OutputAnnotation
forall a. Doc a
line
renderInline a -> String -> Doc OutputAnnotation
pp (Emph Inlines a
txt) = OutputAnnotation -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. a -> Doc a -> Doc a
annotate (TextFormatting -> OutputAnnotation
AnnTextFmt TextFormatting
ItalicText) (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ (a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
txt
renderInline a -> String -> Doc OutputAnnotation
pp (Strong Inlines a
txt) = OutputAnnotation -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. a -> Doc a -> Doc a
annotate (TextFormatting -> OutputAnnotation
AnnTextFmt TextFormatting
BoldText) (Doc OutputAnnotation -> Doc OutputAnnotation)
-> Doc OutputAnnotation -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ (a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
txt
renderInline a -> String -> Doc OutputAnnotation
pp (Code Text
txt a
tm) = a -> String -> Doc OutputAnnotation
pp a
tm (String -> Doc OutputAnnotation) -> String -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
txt
renderInline a -> String -> Doc OutputAnnotation
pp (Link Inlines a
body Text
url Text
title) = OutputAnnotation -> Doc OutputAnnotation -> Doc OutputAnnotation
forall a. a -> Doc a -> Doc a
annotate (String -> OutputAnnotation
AnnLink (Text -> String
T.unpack Text
url)) ((a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
body)
renderInline a -> String -> Doc OutputAnnotation
pp (Image Inlines a
body Text
url Text
title) = String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
"<image>" -- TODO
renderInline a -> String -> Doc OutputAnnotation
pp (Entity Text
a) = String -> Doc OutputAnnotation
forall a. String -> Doc a
text (String -> Doc OutputAnnotation) -> String -> Doc OutputAnnotation
forall a b. (a -> b) -> a -> b
$ String
"<entity " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
a String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
">" -- TODO
renderInline a -> String -> Doc OutputAnnotation
pp (RawHtml Text
txt) = String -> Doc OutputAnnotation
forall a. String -> Doc a
text String
"<html content>" --TODO

-- | The empty docstring
emptyDocstring :: Docstring a
emptyDocstring :: forall a. Docstring a
emptyDocstring = Options -> Blocks a -> Docstring a
forall a. Options -> Blocks a -> Docstring a
DocString Options
options Blocks a
forall a. Seq a
S.empty

-- | Check whether a docstring is emtpy
nullDocstring :: Docstring a -> Bool
nullDocstring :: forall a. Docstring a -> Bool
nullDocstring (DocString Options
_ Blocks a
blocks) = Blocks a -> Bool
forall a. Seq a -> Bool
S.null Blocks a
blocks

-- | Empty documentation for a definition
noDocs :: (Docstring a, [(Name, Docstring a)])
noDocs :: forall a. (Docstring a, [(Name, Docstring a)])
noDocs = (Docstring a
forall a. Docstring a
emptyDocstring, [])

-- | Does a string occur in the docstring?
containsText ::  T.Text -> Docstring a -> Bool
containsText :: forall a. Text -> Docstring a -> Bool
containsText Text
str (DocString Options
_ Blocks a
blocks) = (Block a -> Bool) -> Blocks a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Block a -> Bool
forall a. Text -> Block a -> Bool
blockContains (Text -> Text
T.toLower Text
str)) Blocks a
blocks
  -- blockContains and inlineContains should always be called with a lower-case search string
  where blockContains :: T.Text -> Block a -> Bool
        blockContains :: forall a. Text -> Block a -> Bool
blockContains Text
str (Para Inlines a
inlines) = (Inline a -> Bool) -> Inlines a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Inline a -> Bool
forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
inlines
        blockContains Text
str (Header Int
lvl Inlines a
inlines) = (Inline a -> Bool) -> Inlines a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Inline a -> Bool
forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
inlines
        blockContains Text
str (Blockquote Blocks a
blocks) = (Block a -> Bool) -> Blocks a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Block a -> Bool
forall a. Text -> Block a -> Bool
blockContains Text
str) Blocks a
blocks
        blockContains Text
str (List Bool
b ListType
ty [Blocks a]
blockss) = (Blocks a -> Bool) -> [Blocks a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any ((Block a -> Bool) -> Blocks a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Block a -> Bool
forall a. Text -> Block a -> Bool
blockContains Text
str)) [Blocks a]
blockss
        blockContains Text
str (CodeBlock CodeAttr
attr Text
src a
_) = Text -> Text -> Bool
T.isInfixOf Text
str (Text -> Text
T.toLower Text
src)
        blockContains Text
str (HtmlBlock Text
txt) = Bool
False -- TODO
        blockContains Text
str Block a
HRule = Bool
False

        inlineContains :: T.Text -> Inline a -> Bool
        inlineContains :: forall a. Text -> Inline a -> Bool
inlineContains Text
str (Str Text
s) = Text -> Text -> Bool
T.isInfixOf Text
str (Text -> Text
T.toLower Text
s)
        inlineContains Text
str Inline a
Space = Bool
False
        inlineContains Text
str Inline a
SoftBreak = Bool
False
        inlineContains Text
str Inline a
LineBreak = Bool
False
        inlineContains Text
str (Emph Inlines a
txt) = (Inline a -> Bool) -> Inlines a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Inline a -> Bool
forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
txt
        inlineContains Text
str (Strong Inlines a
txt) = (Inline a -> Bool) -> Inlines a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Inline a -> Bool
forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
txt
        inlineContains Text
str (Code Text
txt a
_) = Text -> Text -> Bool
T.isInfixOf Text
str (Text -> Text
T.toLower Text
txt)
        inlineContains Text
str (Link Inlines a
body Text
url Text
title) = (Inline a -> Bool) -> Inlines a -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (Text -> Inline a -> Bool
forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
body
        inlineContains Text
str (Image Inlines a
body Text
url Text
title) = Bool
False
        inlineContains Text
str (Entity Text
a) = Bool
False
        inlineContains Text
str (RawHtml Text
txt) = Text -> Text -> Bool
T.isInfixOf Text
str (Text -> Text
T.toLower Text
txt)


renderHtml :: Docstring DocTerm -> Html
renderHtml :: Docstring DocTerm -> Html
renderHtml = Doc -> Html
renderDoc (Doc -> Html)
-> (Docstring DocTerm -> Doc) -> Docstring DocTerm -> Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Docstring DocTerm -> Doc
fromDocstring
  where
    fromDocstring :: Docstring DocTerm -> CT.Doc
    fromDocstring :: Docstring DocTerm -> Doc
fromDocstring (DocString Options
opts Blocks DocTerm
blocks) = Options -> Blocks -> Doc
CT.Doc Options
opts ((Block DocTerm -> Block) -> Blocks DocTerm -> Blocks
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block DocTerm -> Block
fromBlock Blocks DocTerm
blocks)

    fromBlock :: Block DocTerm -> CT.Block
    fromBlock :: Block DocTerm -> Block
fromBlock (Para Inlines DocTerm
inlines)           = Inlines -> Block
CT.Para ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
inlines)
    fromBlock (Header Int
i Inlines DocTerm
inlines)       = Int -> Inlines -> Block
CT.Header Int
i ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
inlines)
    fromBlock (Blockquote Blocks DocTerm
blocks)      = Blocks -> Block
CT.Blockquote ((Block DocTerm -> Block) -> Blocks DocTerm -> Blocks
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block DocTerm -> Block
fromBlock Blocks DocTerm
blocks)
    fromBlock (List Bool
b ListType
t [Blocks DocTerm]
blocks)        = Bool -> ListType -> [Blocks] -> Block
CT.List Bool
b ListType
t ((Blocks DocTerm -> Blocks) -> [Blocks DocTerm] -> [Blocks]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Block DocTerm -> Block) -> Blocks DocTerm -> Blocks
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block DocTerm -> Block
fromBlock) [Blocks DocTerm]
blocks)
    fromBlock (CodeBlock CodeAttr
attrs Text
text DocTerm
_) = CodeAttr -> Text -> Block
CT.CodeBlock CodeAttr
attrs Text
text
    fromBlock (HtmlBlock Text
src)          = Text -> Block
CT.HtmlBlock Text
src
    fromBlock Block DocTerm
HRule                    = Block
CT.HRule

    fromInline :: Inline DocTerm -> CT.Inline
    fromInline :: Inline DocTerm -> Inline
fromInline (Str Text
t)              = Text -> Inline
CT.Str Text
t
    fromInline Inline DocTerm
Space                = Inline
CT.Space
    fromInline Inline DocTerm
SoftBreak            = Inline
CT.SoftBreak
    fromInline Inline DocTerm
LineBreak            = Inline
CT.LineBreak
    fromInline (Emph Inlines DocTerm
is)            = Inlines -> Inline
CT.Emph ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
is)
    fromInline (Strong Inlines DocTerm
is)          = Inlines -> Inline
CT.Strong ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
is)
    fromInline (Code Text
src DocTerm
_)         = Text -> Inline
CT.Code Text
src
    fromInline (Link Inlines DocTerm
is Text
url Text
title)  = Inlines -> Text -> Text -> Inline
CT.Link ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
is) Text
url Text
title
    fromInline (Image Inlines DocTerm
is Text
url Text
title) = Inlines -> Text -> Text -> Inline
CT.Image ((Inline DocTerm -> Inline) -> Inlines DocTerm -> Inlines
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline DocTerm -> Inline
fromInline Inlines DocTerm
is) Text
url Text
title
    fromInline (Entity Text
txt)         = Text -> Inline
CT.Entity Text
txt
    fromInline (RawHtml Text
src)        = Text -> Inline
CT.RawHtml Text
src


-- | Annotate the code samples in a docstring
annotCode :: forall a b. (String -> b) -- ^ How to annotate code samples
          -> Docstring a
          -> Docstring b
annotCode :: forall a b. (String -> b) -> Docstring a -> Docstring b
annotCode String -> b
annot (DocString Options
opts Blocks a
blocks)
    = Options -> Blocks b -> Docstring b
forall a. Options -> Blocks a -> Docstring a
DocString Options
opts (Blocks b -> Docstring b) -> Blocks b -> Docstring b
forall a b. (a -> b) -> a -> b
$ (Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block a -> Block b
annotCodeBlock Blocks a
blocks
  where
    annotCodeBlock :: Block a -> Block b
    annotCodeBlock :: Block a -> Block b
annotCodeBlock (Para Inlines a
inlines)          = Inlines b -> Block b
forall a. Inlines a -> Block a
Para ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
inlines)
    annotCodeBlock (Header Int
i Inlines a
inlines)      = Int -> Inlines b -> Block b
forall a. Int -> Inlines a -> Block a
Header Int
i ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
inlines)
    annotCodeBlock (Blockquote Blocks a
blocks)     = Blocks b -> Block b
forall a. Blocks a -> Block a
Blockquote ((Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block a -> Block b
annotCodeBlock Blocks a
blocks)
    annotCodeBlock (List Bool
b ListType
t [Blocks a]
blocks)       = Bool -> ListType -> [Blocks b] -> Block b
forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t ((Blocks a -> Blocks b) -> [Blocks a] -> [Blocks b]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Block a -> Block b) -> Blocks a -> Blocks b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block a -> Block b
annotCodeBlock) [Blocks a]
blocks)
    annotCodeBlock (CodeBlock CodeAttr
attrs Text
src a
_) = CodeAttr -> Text -> b -> Block b
forall a. CodeAttr -> Text -> a -> Block a
CodeBlock CodeAttr
attrs Text
src (String -> b
annot (Text -> String
T.unpack Text
src))
    annotCodeBlock (HtmlBlock Text
src)         = Text -> Block b
forall a. Text -> Block a
HtmlBlock Text
src
    annotCodeBlock Block a
HRule                   = Block b
forall a. Block a
HRule

    annotCodeInline :: Inline a -> Inline b
    annotCodeInline :: Inline a -> Inline b
annotCodeInline (Str Text
t)              = Text -> Inline b
forall a. Text -> Inline a
Str Text
t
    annotCodeInline Inline a
Space                = Inline b
forall a. Inline a
Space
    annotCodeInline Inline a
SoftBreak            = Inline b
forall a. Inline a
SoftBreak
    annotCodeInline Inline a
LineBreak            = Inline b
forall a. Inline a
LineBreak
    annotCodeInline (Emph Inlines a
is)            = Inlines b -> Inline b
forall a. Inlines a -> Inline a
Emph ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
is)
    annotCodeInline (Strong Inlines a
is)          = Inlines b -> Inline b
forall a. Inlines a -> Inline a
Strong ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
is)
    annotCodeInline (Code Text
src a
_)         = Text -> b -> Inline b
forall a. Text -> a -> Inline a
Code Text
src (String -> b
annot (Text -> String
T.unpack Text
src))
    annotCodeInline (Link Inlines a
is Text
url Text
title)  = Inlines b -> Text -> Text -> Inline b
forall a. Inlines a -> Text -> Text -> Inline a
Link ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
is) Text
url Text
title
    annotCodeInline (Image Inlines a
is Text
url Text
title) = Inlines b -> Text -> Text -> Inline b
forall a. Inlines a -> Text -> Text -> Inline a
Image ((Inline a -> Inline b) -> Inlines a -> Inlines b
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline a -> Inline b
annotCodeInline Inlines a
is) Text
url Text
title
    annotCodeInline (Entity Text
txt)         = Text -> Inline b
forall a. Text -> Inline a
Entity Text
txt
    annotCodeInline (RawHtml Text
src)        = Text -> Inline b
forall a. Text -> Inline a
RawHtml Text
src