{-# 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)
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)
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
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)
data Block a = Para (Inlines a)
| 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)
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
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
}
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
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>"
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>"
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
">"
renderInline a -> String -> Doc OutputAnnotation
pp (RawHtml Text
txt) = forall a. String -> Doc a
text String
"<html content>"
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
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
noDocs :: (Docstring a, [(Name, Docstring a)])
noDocs :: forall a. (Docstring a, [(Name, Docstring a)])
noDocs = (forall a. Docstring a
emptyDocstring, [])
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
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
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
annotCode :: forall a b. (String -> b)
-> 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