Markdown.hs

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

-- | Term encoders for hydra.core.markdown

module Hydra.Core.Encode.Markdown where

import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals
import qualified Hydra.Core.Markdown as Markdown
import qualified Hydra.Core.Model as Model
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | Encoder for hydra.core.markdown.Block
block :: Markdown.Block -> Model.Term
block x =
    case x of
      Markdown.BlockCodeBlock v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "codeBlock"),
          Model.fieldTerm = (codeBlock v0)}})
      Markdown.BlockList v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "list"),
          Model.fieldTerm = (list v0)}})
      Markdown.BlockParagraph v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "paragraph"),
          Model.fieldTerm = (paragraph v0)}})
      Markdown.BlockRaw v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "raw"),
          Model.fieldTerm = (Model.TermLiteral (Model.LiteralString v0))}})
      Markdown.BlockSection v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "section"),
          Model.fieldTerm = (section v0)}})
      Markdown.BlockTable v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Block"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "table"),
          Model.fieldTerm = (table v0)}})

-- | Encoder for hydra.core.markdown.CodeBlock
codeBlock :: Markdown.CodeBlock -> Model.Term
codeBlock x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.CodeBlock"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "language"),
          Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Markdown.codeBlockLanguage x))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Markdown.codeBlockContent x))}]})

-- | Encoder for hydra.core.markdown.Document
document :: Markdown.Document -> Model.Term
document x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Document"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "title"),
          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Markdown.documentTitle x))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map block xs)) (Markdown.documentContent x))}]})

-- | Encoder for hydra.core.markdown.Heading
heading :: Markdown.Heading -> Model.Term
heading x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Heading"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "level"),
          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Markdown.headingLevel x))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map inline xs)) (Markdown.headingContent x))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Markdown.headingAnchor x))}]})

-- | Encoder for hydra.core.markdown.Inline
inline :: Markdown.Inline -> Model.Term
inline x =
    case x of
      Markdown.InlineCode v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "code"),
          Model.fieldTerm = (Model.TermLiteral (Model.LiteralString v0))}})
      Markdown.InlineEmphasis v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "emphasis"),
          Model.fieldTerm = (Model.TermList (Lists.map inline v0))}})
      Markdown.InlineLink v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "link"),
          Model.fieldTerm = (link v0)}})
      Markdown.InlineStrong v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "strong"),
          Model.fieldTerm = (Model.TermList (Lists.map inline v0))}})
      Markdown.InlineText v0 -> Model.TermInject (Model.Injection {
        Model.injectionTypeName = (Model.Name "hydra.core.markdown.Inline"),
        Model.injectionField = Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = (Model.TermLiteral (Model.LiteralString v0))}})

-- | Encoder for hydra.core.markdown.Link
link :: Markdown.Link -> Model.Term
link x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Link"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "text"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map inline xs)) (Markdown.linkText x))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Markdown.linkTarget x))}]})

-- | Encoder for hydra.core.markdown.List
list :: Markdown.List -> Model.Term
list x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.List"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ordered"),
          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralBoolean x2)) (Markdown.listOrdered x))},
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map listItem xs)) (Markdown.listItems x))}]})

-- | Encoder for hydra.core.markdown.ListItem
listItem :: Markdown.ListItem -> Model.Term
listItem x =
    Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.ListItem"),
      Model.wrappedTermBody = ((\xs -> Model.TermList (Lists.map block xs)) (Markdown.unListItem x))})

-- | Encoder for hydra.core.markdown.Paragraph
paragraph :: Markdown.Paragraph -> Model.Term
paragraph x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Paragraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map inline xs)) (Markdown.paragraphContent x))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Markdown.paragraphAnchor x))}]})

-- | Encoder for hydra.core.markdown.Section
section :: Markdown.Section -> Model.Term
section x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Section"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "heading"),
          Model.fieldTerm = (heading (Markdown.sectionHeading x))},
        Model.Field {
          Model.fieldName = (Model.Name "content"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map block xs)) (Markdown.sectionContent x))},
        Model.Field {
          Model.fieldName = (Model.Name "anchor"),
          Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) opt)) (Markdown.sectionAnchor x))}]})

-- | Encoder for hydra.core.markdown.Table
table :: Markdown.Table -> Model.Term
table x =
    Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.core.markdown.Table"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (tableRow (Markdown.tableHeader x))},
        Model.Field {
          Model.fieldName = (Model.Name "rows"),
          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map tableRow xs)) (Markdown.tableRows x))}]})

-- | Encoder for hydra.core.markdown.TableCell
tableCell :: Markdown.TableCell -> Model.Term
tableCell x =
    Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.TableCell"),
      Model.wrappedTermBody = ((\xs -> Model.TermList (Lists.map inline xs)) (Markdown.unTableCell x))})

-- | Encoder for hydra.core.markdown.TableRow
tableRow :: Markdown.TableRow -> Model.Term
tableRow x =
    Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.core.markdown.TableRow"),
      Model.wrappedTermBody = ((\xs -> Model.TermList (Lists.map tableCell xs)) (Markdown.unTableRow x))})