{-|
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
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DocTerm] -> ShowS
$cshowList :: [DocTerm] -> ShowS
show :: DocTerm -> String
$cshow :: DocTerm -> String
showsPrec :: Int -> DocTerm -> ShowS
$cshowsPrec :: Int -> DocTerm -> ShowS
Show, 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
$cto :: forall x. Rep DocTerm x -> DocTerm
$cfrom :: forall x. DocTerm -> Rep DocTerm x
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 = 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 = forall a. Doc a -> Doc a
align forall a b. (a -> b) -> a -> b
$
                                                forall a. String -> Doc a
text String
">" forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a -> Doc a
align (Term -> Doc OutputAnnotation
pp Term
tm) 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 = forall a. a -> Doc a -> Doc a
annotate (Err -> OutputAnnotation
AnnErr Err
err) forall a b. (a -> b) -> a -> b
$ 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
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
showList :: [Docstring a] -> ShowS
$cshowList :: forall a. Show a => [Docstring a] -> ShowS
show :: Docstring a -> String
$cshow :: forall a. Show a => Docstring a -> String
showsPrec :: Int -> Docstring a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Docstring a -> ShowS
Show, 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
<$ :: forall a b. a -> Docstring b -> Docstring a
$c<$ :: forall a b. a -> Docstring b -> Docstring a
fmap :: forall a b. (a -> b) -> Docstring a -> Docstring b
$cfmap :: forall a b. (a -> b) -> Docstring a -> Docstring b
Functor, 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
product :: forall a. Num a => Docstring a -> a
$cproduct :: forall a. Num a => Docstring a -> a
sum :: forall a. Num a => Docstring a -> a
$csum :: forall a. Num a => Docstring a -> a
minimum :: forall a. Ord a => Docstring a -> a
$cminimum :: forall a. Ord a => Docstring a -> a
maximum :: forall a. Ord a => Docstring a -> a
$cmaximum :: forall a. Ord a => Docstring a -> a
elem :: forall a. Eq a => a -> Docstring a -> Bool
$celem :: forall a. Eq a => a -> Docstring a -> Bool
length :: forall a. Docstring a -> Int
$clength :: forall a. Docstring a -> Int
null :: forall a. Docstring a -> Bool
$cnull :: forall a. Docstring a -> Bool
toList :: forall a. Docstring a -> [a]
$ctoList :: forall a. Docstring a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Docstring a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Docstring a -> a
foldr1 :: forall a. (a -> a -> a) -> Docstring a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Docstring a -> a
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
$cfoldl :: forall b a. (b -> a -> 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
$cfoldr :: forall a b. (a -> b -> b) -> b -> Docstring a -> b
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
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Docstring a -> m
fold :: forall m. Monoid m => Docstring m -> m
$cfold :: forall m. Monoid m => Docstring m -> m
Foldable, Functor Docstring
Foldable 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)
sequence :: forall (m :: * -> *) a.
Monad m =>
Docstring (m a) -> m (Docstring a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Docstring (m a) -> m (Docstring a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Docstring a -> m (Docstring b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Docstring a -> m (Docstring b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Docstring (f a) -> f (Docstring a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Docstring (f a) -> f (Docstring a)
traverse :: 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)
Traversable, 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
$cto :: forall a x. Rep (Docstring a) x -> Docstring a
$cfrom :: forall a x. Docstring a -> Rep (Docstring a) x
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
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
showList :: [Block a] -> ShowS
$cshowList :: forall a. Show a => [Block a] -> ShowS
show :: Block a -> String
$cshow :: forall a. Show a => Block a -> String
showsPrec :: Int -> Block a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Block a -> ShowS
Show, 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
<$ :: forall a b. a -> Block b -> Block a
$c<$ :: forall a b. a -> Block b -> Block a
fmap :: forall a b. (a -> b) -> Block a -> Block b
$cfmap :: forall a b. (a -> b) -> Block a -> Block b
Functor, 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
product :: forall a. Num a => Block a -> a
$cproduct :: forall a. Num a => Block a -> a
sum :: forall a. Num a => Block a -> a
$csum :: forall a. Num a => Block a -> a
minimum :: forall a. Ord a => Block a -> a
$cminimum :: forall a. Ord a => Block a -> a
maximum :: forall a. Ord a => Block a -> a
$cmaximum :: forall a. Ord a => Block a -> a
elem :: forall a. Eq a => a -> Block a -> Bool
$celem :: forall a. Eq a => a -> Block a -> Bool
length :: forall a. Block a -> Int
$clength :: forall a. Block a -> Int
null :: forall a. Block a -> Bool
$cnull :: forall a. Block a -> Bool
toList :: forall a. Block a -> [a]
$ctoList :: forall a. Block a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Block a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Block a -> a
foldr1 :: forall a. (a -> a -> a) -> Block a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Block a -> a
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
$cfoldl :: forall b a. (b -> a -> 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
$cfoldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
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
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
fold :: forall m. Monoid m => Block m -> m
$cfold :: forall m. Monoid m => Block m -> m
Foldable, Functor Block
Foldable 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)
sequence :: forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a)
$csequence :: forall (m :: * -> *) a. Monad m => Block (m a) -> m (Block a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Block a -> m (Block b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Block a -> m (Block b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Block (f a) -> f (Block a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Block (f a) -> f (Block a)
traverse :: 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)
Traversable, 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
$cto :: forall a x. Rep (Block a) x -> Block a
$cfrom :: forall a x. Block a -> Rep (Block a) x
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
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
showList :: [Inline a] -> ShowS
$cshowList :: forall a. Show a => [Inline a] -> ShowS
show :: Inline a -> String
$cshow :: forall a. Show a => Inline a -> String
showsPrec :: Int -> Inline a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Inline a -> ShowS
Show, 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
<$ :: forall a b. a -> Inline b -> Inline a
$c<$ :: forall a b. a -> Inline b -> Inline a
fmap :: forall a b. (a -> b) -> Inline a -> Inline b
$cfmap :: forall a b. (a -> b) -> Inline a -> Inline b
Functor, 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
product :: forall a. Num a => Inline a -> a
$cproduct :: forall a. Num a => Inline a -> a
sum :: forall a. Num a => Inline a -> a
$csum :: forall a. Num a => Inline a -> a
minimum :: forall a. Ord a => Inline a -> a
$cminimum :: forall a. Ord a => Inline a -> a
maximum :: forall a. Ord a => Inline a -> a
$cmaximum :: forall a. Ord a => Inline a -> a
elem :: forall a. Eq a => a -> Inline a -> Bool
$celem :: forall a. Eq a => a -> Inline a -> Bool
length :: forall a. Inline a -> Int
$clength :: forall a. Inline a -> Int
null :: forall a. Inline a -> Bool
$cnull :: forall a. Inline a -> Bool
toList :: forall a. Inline a -> [a]
$ctoList :: forall a. Inline a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Inline a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Inline a -> a
foldr1 :: forall a. (a -> a -> a) -> Inline a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Inline a -> a
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
$cfoldl :: forall b a. (b -> a -> 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
$cfoldr :: forall a b. (a -> b -> b) -> b -> Inline a -> b
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
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Inline a -> m
fold :: forall m. Monoid m => Inline m -> m
$cfold :: forall m. Monoid m => Inline m -> m
Foldable, Functor Inline
Foldable 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)
sequence :: forall (m :: * -> *) a. Monad m => Inline (m a) -> m (Inline a)
$csequence :: forall (m :: * -> *) a. Monad m => Inline (m a) -> m (Inline a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Inline a -> m (Inline b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Inline a -> m (Inline b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Inline (f a) -> f (Inline a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Inline (f a) -> f (Inline a)
traverse :: 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)
Traversable, 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
$cto :: forall a x. Rep (Inline a) x -> Inline a
$cfrom :: forall a x. Inline a -> Rep (Inline a) x
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) = forall a. Options -> Blocks a -> Docstring a
DocString Options
opts (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)           = forall a. Inlines a -> Block a
Para (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)       = forall a. Int -> Inlines a -> Block a
Header Int
i (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)          = forall a. Blocks a -> Block a
Blockquote (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)        = forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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) = forall a. CodeAttr -> Text -> a -> Block a
CodeBlock CodeAttr
attrs Text
src
                                                          (String -> [String] -> String -> a -> b
f (Text -> String
T.unpack forall a b. (a -> b) -> a -> b
$ CodeAttr -> Text
CT.codeLang CodeAttr
attrs)
                                                             (String -> [String]
words forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack 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)          = forall a. Text -> Block a
HtmlBlock Text
src
        checkBlock String -> [String] -> String -> a -> b
f Block a
HRule                    = 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)            = forall a. Text -> Inline a
Str Text
txt
        checkInline String -> [String] -> String -> a -> b
f Inline a
Space                = forall a. Inline a
Space
        checkInline String -> [String] -> String -> a -> b
f Inline a
SoftBreak            = forall a. Inline a
SoftBreak
        checkInline String -> [String] -> String -> a -> b
f Inline a
LineBreak            = forall a. Inline a
LineBreak
        checkInline String -> [String] -> String -> a -> b
f (Emph Inlines a
is)            = forall a. Inlines a -> Inline a
Emph (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)          = forall a. Inlines a -> Inline a
Strong (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)         = 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)  = forall a. Inlines a -> Text -> Text -> Inline a
Link (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) = forall a. Inlines a -> Text -> Text -> Inline a
Image (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)         = forall a. Text -> Inline a
Entity Text
txt
        checkInline String -> [String] -> String -> a -> b
f (RawHtml Text
src)        = 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 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) = forall a. Options -> Blocks a -> Docstring a
DocString Options
opts (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)         = forall a. Inlines a -> Block a
Para (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)     = forall a. Int -> Inlines a -> Block a
Header Int
i (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
inlines)
        toBlock (CT.Blockquote Blocks
blocks)    = forall a. Blocks a -> Block a
Blockquote (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)      = forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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) = forall a. CodeAttr -> Text -> a -> Block a
CodeBlock CodeAttr
attrs Text
text ()
        toBlock (CT.HtmlBlock Text
src)        = forall a. Text -> Block a
HtmlBlock Text
src
        toBlock Block
CT.HRule                  = forall a. Block a
HRule

        toInline :: CT.Inline -> Inline ()
        toInline :: Inline -> Inline ()
toInline (CT.Str Text
t)              = forall a. Text -> Inline a
Str Text
t
        toInline Inline
CT.Space                = forall a. Inline a
Space
        toInline Inline
CT.SoftBreak            = forall a. Inline a
SoftBreak
        toInline Inline
CT.LineBreak            = forall a. Inline a
LineBreak
        toInline (CT.Emph Inlines
is)            = forall a. Inlines a -> Inline a
Emph (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is)
        toInline (CT.Strong Inlines
is)          = forall a. Inlines a -> Inline a
Strong (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Inline -> Inline ()
toInline Inlines
is)
        toInline (CT.Code Text
src)           = forall a. Text -> a -> Inline a
Code Text
src ()
        toInline (CT.Link Inlines
is Text
url Text
title)  = forall a. Inlines a -> Text -> Text -> Inline a
Link (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) = forall a. Inlines a -> Text -> Text -> Inline a
Image (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)         = forall a. Text -> Inline a
Entity Text
txt
        toInline (CT.RawHtml Text
src)        = 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) = 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) = forall a. Options -> Blocks a -> Docstring a
DocString Options
opts (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  | forall a. Seq a -> Int
S.length Blocks a
blocks forall a. Ord a => a -> a -> Bool
> Int
1  = forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
F.foldr1 (\Doc OutputAnnotation
b1 Doc OutputAnnotation
b2 -> Doc OutputAnnotation
b1 forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> forall a. Doc a
line forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
b2) forall a b. (a -> b) -> a -> b
$
                                                  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a.
(a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
renderBlock a -> String -> Doc OutputAnnotation
pp) Blocks a
blocks
                        | forall a. Seq a -> Int
S.length Blocks a
blocks forall a. Eq a => a -> a -> Bool
== Int
1 = forall a.
(a -> String -> Doc OutputAnnotation)
-> Block a -> Doc OutputAnnotation
renderBlock a -> String -> Doc OutputAnnotation
pp (forall a. Seq a -> Int -> a
S.index Blocks a
blocks Int
0)
                        | Bool
otherwise            = 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) = 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) = forall a.
(a -> String -> Doc OutputAnnotation)
-> Inlines a -> Doc OutputAnnotation
renderInlines a -> String -> Doc OutputAnnotation
pp Inlines a
inlines forall a. Doc a -> Doc a -> Doc a
<+> forall a. Doc a -> Doc a
parens (forall a. String -> Doc a
text (forall a. Show a => a -> String
show Int
lvl))
renderBlock a -> String -> Doc OutputAnnotation
pp (Blockquote Blocks a
blocks) = forall a. Int -> Doc a -> Doc a
indent Int
8 forall a b. (a -> b) -> a -> b
$ 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) = 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) = forall a. Int -> Doc a -> Doc a
indent Int
4 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) = forall a. String -> Doc a
text String
"<html block>" -- TODO
renderBlock a -> String -> Doc OutputAnnotation
pp Block a
HRule = 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 = forall a. [Doc a] -> Doc a
vsep forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall a. Int -> Doc a -> Doc a
hang Int
4 forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Char -> Doc a
char Char
c forall a. Doc a -> Doc a -> Doc a
<+>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 =
  forall a. [Doc a] -> Doc a
vsep forall a b. (a -> b) -> a -> b
$
  forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith3 (\Int
n Doc OutputAnnotation
p Doc OutputAnnotation
txt -> forall a. Int -> Doc a -> Doc a
hang Int
4 forall a b. (a -> b) -> a -> b
$ forall a. String -> Doc a
text (forall a. Show a => a -> String
show Int
n) forall a. Doc a -> Doc a -> Doc a
<> Doc OutputAnnotation
p forall a. Doc a -> Doc a -> Doc a
<+> Doc OutputAnnotation
txt)
           [Int
i..] (forall a. a -> [a]
repeat forall a. Doc a
punc) (forall a b. (a -> b) -> [a] -> [b]
map (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 -> forall a. Char -> Doc a
char Char
'.'
                 NumWrapper
CT.ParenFollowing  -> 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 = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
F.foldr forall a. Doc a -> Doc a -> Doc a
(<>) forall a. Doc a
empty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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) = forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
s
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
Space = forall a. Doc a
softline
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
SoftBreak = forall a. Doc a
softline
renderInline a -> String -> Doc OutputAnnotation
pp Inline a
LineBreak = forall a. Doc a
line
renderInline a -> String -> Doc OutputAnnotation
pp (Emph Inlines a
txt) = forall a. a -> Doc a -> Doc a
annotate (TextFormatting -> OutputAnnotation
AnnTextFmt TextFormatting
ItalicText) forall a b. (a -> b) -> a -> b
$ 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) = forall a. a -> Doc a -> Doc a
annotate (TextFormatting -> OutputAnnotation
AnnTextFmt TextFormatting
BoldText) forall a b. (a -> b) -> a -> b
$ 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 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) = forall a. a -> Doc a -> Doc a
annotate (String -> OutputAnnotation
AnnLink (Text -> String
T.unpack Text
url)) (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) = forall a. String -> Doc a
text String
"<image>" -- TODO
renderInline a -> String -> Doc OutputAnnotation
pp (Entity Text
a) = forall a. String -> Doc a
text forall a b. (a -> b) -> a -> b
$ String
"<entity " forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
a forall a. [a] -> [a] -> [a]
++ String
">" -- TODO
renderInline a -> String -> Doc OutputAnnotation
pp (RawHtml Text
txt) = forall a. String -> Doc a
text String
"<html content>" --TODO

-- | The empty docstring
emptyDocstring :: Docstring a
emptyDocstring :: forall a. Docstring a
emptyDocstring = forall a. Options -> Blocks a -> Docstring a
DocString Options
options 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) = 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 = (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) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (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) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
inlines
        blockContains Text
str (Header Int
lvl Inlines a
inlines) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
inlines
        blockContains Text
str (Blockquote Blocks a
blocks) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (forall a. Text -> Block a -> Bool
blockContains Text
str) Blocks a
blocks
        blockContains Text
str (List Bool
b ListType
ty [Blocks a]
blockss) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (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) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (forall a. Text -> Inline a -> Bool
inlineContains Text
str) Inlines a
txt
        inlineContains Text
str (Strong Inlines a
txt) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (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) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
F.any (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 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 (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 (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 (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 (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 (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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 (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 (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 (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 (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)
    = forall a. Options -> Blocks a -> Docstring a
DocString Options
opts forall a b. (a -> b) -> a -> 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)          = forall a. Inlines a -> Block a
Para (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)      = forall a. Int -> Inlines a -> Block a
Header Int
i (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)     = forall a. Blocks a -> Block a
Blockquote (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)       = forall a. Bool -> ListType -> [Blocks a] -> Block a
List Bool
b ListType
t (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (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
_) = 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)         = forall a. Text -> Block a
HtmlBlock Text
src
    annotCodeBlock Block a
HRule                   = forall a. Block a
HRule

    annotCodeInline :: Inline a -> Inline b
    annotCodeInline :: Inline a -> Inline b
annotCodeInline (Str Text
t)              = forall a. Text -> Inline a
Str Text
t
    annotCodeInline Inline a
Space                = forall a. Inline a
Space
    annotCodeInline Inline a
SoftBreak            = forall a. Inline a
SoftBreak
    annotCodeInline Inline a
LineBreak            = forall a. Inline a
LineBreak
    annotCodeInline (Emph Inlines a
is)            = forall a. Inlines a -> Inline a
Emph (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)          = forall a. Inlines a -> Inline a
Strong (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
_)         = 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)  = forall a. Inlines a -> Text -> Text -> Inline a
Link (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) = forall a. Inlines a -> Text -> Text -> Inline a
Image (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)         = forall a. Text -> Inline a
Entity Text
txt
    annotCodeInline (RawHtml Text
src)        = forall a. Text -> Inline a
RawHtml Text
src