220 lines
7.3 KiB
Plaintext
220 lines
7.3 KiB
Plaintext
/-
|
|
Copyright (c) 2021 Henrik Böving. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
Authors: Henrik Böving
|
|
-/
|
|
import DocGen4.Output.Template
|
|
import DocGen4.Output.Inductive
|
|
import DocGen4.Output.Structure
|
|
import DocGen4.Output.Class
|
|
import DocGen4.Output.Definition
|
|
import DocGen4.Output.Instance
|
|
import DocGen4.Output.ClassInductive
|
|
import DocGen4.Output.DocString
|
|
import DocGen4.Process
|
|
import Lean.Data.Xml.Parser
|
|
|
|
namespace DocGen4
|
|
namespace Output
|
|
|
|
open scoped DocGen4.Jsx
|
|
open Lean Process
|
|
|
|
/--
|
|
Render an `Arg` as HTML, adding opacity effects etc. depending on what
|
|
type of binder it has.
|
|
-/
|
|
def argToHtml (arg : Arg) : HtmlM Html := do
|
|
let (l, r, implicit) := match arg.binderInfo with
|
|
| BinderInfo.default => ("(", ")", false)
|
|
| BinderInfo.implicit => ("{", "}", true)
|
|
| BinderInfo.strictImplicit => ("⦃", "⦄", true)
|
|
| BinderInfo.instImplicit => ("[", "]", true)
|
|
let mut nodes :=
|
|
match arg.name with
|
|
| some name => #[Html.text s!"{l}{name.toString} : "]
|
|
| none => #[Html.text s!"{l}"]
|
|
nodes := nodes.append (← infoFormatToHtml arg.type)
|
|
nodes := nodes.push r
|
|
let inner := <span class="fn">[nodes]</span>
|
|
let html := Html.element "span" false #[("class", "decl_args")] #[inner]
|
|
if implicit then
|
|
return <span class="impl_arg">{html}</span>
|
|
else
|
|
return html
|
|
|
|
/--
|
|
Render the structures this structure extends from as HTML so it can be
|
|
added to the top level.
|
|
-/
|
|
def structureInfoHeader (s : Process.StructureInfo) : HtmlM (Array Html) := do
|
|
let mut nodes := #[]
|
|
if s.parents.size > 0 then
|
|
nodes := nodes.push <span class="decl_extends">extends</span>
|
|
let mut parents := #[]
|
|
for parent in s.parents do
|
|
let link ← declNameToHtmlBreakWithinLink parent
|
|
let inner := <span class="fn">{link}</span>
|
|
let html:= Html.element "span" false #[("class", "decl_parent")] #[inner]
|
|
parents := parents.push html
|
|
nodes := nodes.append (parents.toList.intersperse (Html.text ", ")).toArray
|
|
return nodes
|
|
|
|
/--
|
|
Render the general header of a declaration containing its declaration type
|
|
and name.
|
|
-/
|
|
def docInfoHeader (doc : DocInfo) : HtmlM Html := do
|
|
let mut nodes := #[]
|
|
nodes := nodes.push <| Html.element "span" false #[("class", "decl_kind")] #[doc.getKindDescription]
|
|
nodes := nodes.push
|
|
<span class="decl_name">
|
|
{← declNameToHtmlBreakWithinLink doc.getName}
|
|
</span>
|
|
for arg in doc.getArgs do
|
|
nodes := nodes.push (← argToHtml arg)
|
|
|
|
match doc with
|
|
| DocInfo.structureInfo i => nodes := nodes.append (← structureInfoHeader i)
|
|
| DocInfo.classInfo i => nodes := nodes.append (← structureInfoHeader i)
|
|
| _ => nodes := nodes
|
|
|
|
nodes := nodes.push <| Html.element "span" true #[("class", "decl_args")] #[" :"]
|
|
nodes := nodes.push <div class="decl_type">[← infoFormatToHtml doc.getType]</div>
|
|
return <div class="decl_header"> [nodes] </div>
|
|
|
|
/--
|
|
The main entry point for rendering a single declaration inside a given module.
|
|
-/
|
|
def docInfoToHtml (module : Name) (doc : DocInfo) : HtmlM Html := do
|
|
-- basic info like headers, types, structure fields, etc.
|
|
let docInfoHtml ← match doc with
|
|
| DocInfo.inductiveInfo i => inductiveToHtml i
|
|
| DocInfo.structureInfo i => structureToHtml i
|
|
| DocInfo.classInfo i => classToHtml i
|
|
| DocInfo.classInductiveInfo i => classInductiveToHtml i
|
|
| _ => pure #[]
|
|
-- rendered doc stirng
|
|
let docStringHtml ← match doc.getDocString with
|
|
| some s => docStringToHtml s
|
|
| none => pure #[]
|
|
-- extra information like equations and instances
|
|
let extraInfoHtml ← match doc with
|
|
| DocInfo.classInfo i => pure #[← classInstancesToHtml i.name]
|
|
| DocInfo.definitionInfo i => pure ((← equationsToHtml i) ++ #[← instancesForToHtml i.name])
|
|
| DocInfo.instanceInfo i => equationsToHtml i.toDefinitionInfo
|
|
| DocInfo.classInductiveInfo i => pure #[← classInstancesToHtml i.name]
|
|
| DocInfo.inductiveInfo i => pure #[← instancesForToHtml i.name]
|
|
| DocInfo.structureInfo i => pure #[← instancesForToHtml i.name]
|
|
| _ => pure #[]
|
|
let attrs := doc.getAttrs
|
|
let attrsHtml :=
|
|
if attrs.size > 0 then
|
|
let attrStr := "@[" ++ String.intercalate ", " doc.getAttrs.toList ++ "]"
|
|
#[Html.element "div" false #[("class", "attributes")] #[attrStr]]
|
|
else
|
|
#[]
|
|
let leanInkHtml :=
|
|
if ← leanInkEnabled? then
|
|
#[
|
|
<div class="ink_link">
|
|
<a href={← declNameToInkLink doc.getName}>ink</a>
|
|
</div>
|
|
]
|
|
else
|
|
#[]
|
|
|
|
pure
|
|
<div class="decl" id={doc.getName.toString}>
|
|
<div class={doc.getKind}>
|
|
<div class="gh_link">
|
|
<a href={← getSourceUrl module doc.getDeclarationRange}>source</a>
|
|
</div>
|
|
[leanInkHtml]
|
|
[attrsHtml]
|
|
{← docInfoHeader doc}
|
|
[docStringHtml]
|
|
[docInfoHtml]
|
|
[extraInfoHtml]
|
|
</div>
|
|
</div>
|
|
|
|
/--
|
|
Rendering a module doc string, that is the ones with an ! after the opener
|
|
as HTML.
|
|
-/
|
|
def modDocToHtml (mdoc : ModuleDoc) : HtmlM Html := do
|
|
pure
|
|
<div class="mod_doc">
|
|
[← docStringToHtml mdoc.doc]
|
|
</div>
|
|
|
|
/--
|
|
Render a module member, that is either a module doc string or a declaration
|
|
as HTML.
|
|
-/
|
|
def moduleMemberToHtml (module : Name) (member : ModuleMember) : HtmlM Html := do
|
|
match member with
|
|
| ModuleMember.docInfo d => docInfoToHtml module d
|
|
| ModuleMember.modDoc d => modDocToHtml d
|
|
|
|
def declarationToNavLink (module : Name) : Html :=
|
|
<div class="nav_link">
|
|
<a class="break_within" href={s!"#{module.toString}"}>
|
|
[breakWithin module.toString]
|
|
</a>
|
|
</div>
|
|
|
|
/--
|
|
Returns the list of all imports this module does.
|
|
-/
|
|
def getImports (module : Name) : HtmlM (Array Name) := do
|
|
let res ← getResult
|
|
return res.moduleInfo.find! module |>.imports
|
|
|
|
/--
|
|
Sort the list of all modules this one is importing, linkify it
|
|
and return the HTML.
|
|
-/
|
|
def importsHtml (moduleName : Name) : HtmlM (Array Html) := do
|
|
let imports := (← getImports moduleName).qsort Name.lt
|
|
imports.mapM (fun i => do return <li>{← moduleToHtmlLink i}</li>)
|
|
|
|
/--
|
|
Render the internal nav bar (the thing on the right on all module pages).
|
|
-/
|
|
def internalNav (members : Array Name) (moduleName : Name) : HtmlM Html := do
|
|
pure
|
|
<nav class="internal_nav">
|
|
<h3><a class="break_within" href="#top">[breakWithin moduleName.toString]</a></h3>
|
|
<p class="gh_nav_link"><a href={← getSourceUrl moduleName none}>source</a></p>
|
|
<div class="imports">
|
|
<details>
|
|
<summary>Imports</summary>
|
|
<ul>
|
|
[← importsHtml moduleName]
|
|
</ul>
|
|
</details>
|
|
<details>
|
|
<summary>Imported by</summary>
|
|
<ul id={s!"imported-by-{moduleName}"} class="imported-by-list"> </ul>
|
|
</details>
|
|
</div>
|
|
[members.map declarationToNavLink]
|
|
</nav>
|
|
|
|
/--
|
|
The main entry point to rendering the HTML for an entire module.
|
|
-/
|
|
def moduleToHtml (module : Process.Module) : HtmlM Html := withTheReader SiteBaseContext (setCurrentName module.name) do
|
|
let relevantMembers := module.members.filter Process.ModuleMember.shouldRender
|
|
let memberDocs ← relevantMembers.mapM (moduleMemberToHtml module.name)
|
|
let memberNames := filterDocInfo relevantMembers |>.map DocInfo.getName
|
|
templateLiftExtends (baseHtmlGenerator module.name.toString) <| pure #[
|
|
← internalNav memberNames module.name,
|
|
Html.element "main" false #[] memberDocs
|
|
]
|
|
|
|
end Output
|
|
end DocGen4
|