Markdown.hs

-- Note: this is an automatically generated file. Do not edit.

-- | Serialization of hydra.core.markdown documents to Markdown text

module Hydra.Core.Print.Markdown where

import qualified Hydra.Core.Ast as Ast
import qualified Hydra.Core.Coders as Coders
import qualified Hydra.Core.Diff as Diff
import qualified Hydra.Core.Docs as Docs
import qualified Hydra.Core.Error.Checking as Checking
import qualified Hydra.Core.Error.File as ErrorFile
import qualified Hydra.Core.Error.Model as ErrorModel
import qualified Hydra.Core.Error.Packaging as ErrorPackaging
import qualified Hydra.Core.Error.System as ErrorSystem
import qualified Hydra.Core.Errors as Errors
import qualified Hydra.Core.File as File
import qualified Hydra.Core.Formatting as Formatting
import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Json.Model as JsonModel
import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals
import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic
import qualified Hydra.Core.Overlay.Haskell.Lib.Math as Math
import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals
import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs
import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings
import qualified Hydra.Core.Markdown as Markdown
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Packaging as Packaging
import qualified Hydra.Core.Parsing as Parsing
import qualified Hydra.Core.Paths as Paths
import qualified Hydra.Core.Query as Query
import qualified Hydra.Core.Regex as Regex
import qualified Hydra.Core.Relational as Relational
import qualified Hydra.Core.System as System
import qualified Hydra.Core.Tabular as Tabular
import qualified Hydra.Core.Testing as Testing
import qualified Hydra.Core.Time as Time
import qualified Hydra.Core.Topology as Topology
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Core.Typing as Typing
import qualified Hydra.Core.Util as Util
import qualified Hydra.Core.Validation as Validation
import qualified Hydra.Core.Variants as Variants
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | Render a single Block to its Markdown text form
block :: Markdown.Block -> String
block b =
    case b of
      Markdown.BlockCodeBlock v0 -> codeBlock v0
      Markdown.BlockList v0 -> list v0
      Markdown.BlockParagraph v0 -> inlines (Markdown.paragraphContent v0)
      Markdown.BlockRaw v0 -> v0
      Markdown.BlockSection v0 ->
        let h = Markdown.sectionHeading v0
            content = Markdown.sectionContent v0
        in (Strings.join "\n\n" (Lists.cons (heading h) (Lists.map block content)))
      Markdown.BlockTable v0 -> table v0

-- | Render a list of Blocks, joined by a blank line
blocks :: [Markdown.Block] -> String
blocks bs = Strings.join "\n\n" (Lists.map block bs)

-- | Render a CodeBlock as a fenced code block, with the language tag on the opening fence if present
codeBlock :: Markdown.CodeBlock -> String
codeBlock cb =

      let lang = Markdown.codeBlockLanguage cb
          content = Markdown.codeBlockContent cb
          fence = Strings.concat2 "```" (Optionals.withDefault "" lang)
      in (Strings.join "\n" [
        fence,
        content,
        "```"])

-- | Render a Document as its complete Markdown text, an H1 title followed by its blocks
document :: Markdown.Document -> String
document d =

      let title = Markdown.documentTitle d
          content = Markdown.documentContent d
      in (Strings.join "\n\n" (Lists.cons (Strings.concat2 "# " title) (Lists.map block content)))

-- | Render a Heading, prefixing its inline content with the appropriate number of `#` characters
heading :: Markdown.Heading -> String
heading h =

      let level = Markdown.headingLevel h
          content = Markdown.headingContent h
          hashes = Strings.concat (Lists.replicate level "#")
      in (Strings.concat2 (Strings.concat2 hashes " ") (inlines content))

-- | Render a single Inline to its Markdown text form
inline :: Markdown.Inline -> String
inline i =
    case i of
      Markdown.InlineCode v0 -> Strings.concat2 (Strings.concat2 "`" v0) "`"
      Markdown.InlineEmphasis v0 -> Strings.concat2 (Strings.concat2 "*" (inlines v0)) "*"
      Markdown.InlineLink v0 -> link v0
      Markdown.InlineStrong v0 -> Strings.concat2 (Strings.concat2 "**" (inlines v0)) "**"
      Markdown.InlineText v0 -> v0

-- | Render a list of Inlines, concatenated with no separator
inlines :: [Markdown.Inline] -> String
inlines is = Strings.concat (Lists.map inline is)

-- | Render a Link in the standard `[text](target)` form
link :: Markdown.Link -> String
link lk =

      let text = Markdown.linkText lk
          target = Markdown.linkTarget lk
      in (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "[" (inlines text)) "](") target) ")")

-- | Render a List as bulleted (`-`) or numbered (`1.`, `2.`, ...) lines, one per item; item content is joined with a blank line for items spanning multiple blocks
list :: Markdown.List -> String
list l =

      let ordered = Markdown.listOrdered l
          items = Markdown.listItems l
          itemContent = \it -> blocks (Markdown.unListItem it)
          indices = Math.range 0 (Lists.length items)
          indexedItems = Lists.zip indices items
          renderIndexed =
                  \ip ->
                    let idx = Pairs.first ip
                        it = Pairs.second ip
                        marker = Logic.ifElse ordered (Strings.concat2 (Literals.printInt32 (Math.add idx 1)) ".") "-"
                    in (Strings.concat2 (Strings.concat2 marker " ") (itemContent it))
      in (Strings.join "\n" (Lists.map renderIndexed indexedItems))

-- | Render a Table in GitHub-flavored Markdown pipe-table form, with a `---` separator row after the header
table :: Markdown.Table -> String
table t =

      let header = Markdown.tableHeader t
          rows = Markdown.tableRows t
          headerCells = Markdown.unTableRow header
          sepRow = Strings.concat2 "|" (Strings.concat (Lists.map (\_ -> " --- |") headerCells))
      in (Strings.join "\n" (Lists.cons (tableRow header) (Lists.cons sepRow (Lists.map tableRow rows))))

-- | Render a TableCell's inline content
tableCell :: Markdown.TableCell -> String
tableCell c = inlines (Markdown.unTableCell c)

-- | Render a TableRow as a pipe-delimited line
tableRow :: Markdown.TableRow -> String
tableRow r =

      let cells = Markdown.unTableRow r
      in (Strings.concat2 (Strings.concat2 "| " (Strings.join " | " (Lists.map tableCell cells))) " |")