Add blog posts summary index page

Author: BarkingBad

scala3doc/src/dotty/dokka/site/PartiallyRenderedContent.scala

@@ -7,6 +7,7 @@ import org.jetbrains.dokka.pages.{ContentNode, DCI, Style}
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
 import com.vladsch.flexmark.convert.html.FlexmarkHtmlParser
 import org.jsoup.Jsoup
+import scala.collection.JavaConverters._
 
 case class PartiallyRenderedContent(
   template: TemplateFile,

scala3doc/src/dotty/dokka/site/StaticSiteContext.scala

@@ -78,12 +78,16 @@ class StaticSiteContext(val root: File, sourceSets: Set[SourceSetWrapper]):
         if (indexes.size > 1)
           // TODO (https://github.com/lampepfl/scala3doc/issues/238): provide proper error handling
           println(s"ERROR: Multiple index pages for $from found in ${indexes.map(_.file)}")
-
         def loadIndexPage(): TemplateFile =
           val indexFiles = from.listFiles { file =>file.getName == "index.md" || file.getName == "index.html" }
           indexFiles.size match
             case 0 => emptyTemplate(from, from.getName)
-            case 1 => loadTemplateFile(indexFiles.head).copy(file = from)
+            case 1 => 
+              val index = loadTemplateFile(indexFiles.head)
+              index.copy(
+                file = from,
+                settings = index.settings ++ Map("site" -> Map("posts" -> children.map(_.templateFile.settings("page"))))
+              )
             case _ =>
               val msg = s"ERROR: Multiple index pages found under ${from.toPath}"
               throw new java.lang.RuntimeException(msg)

scala3doc/src/dotty/dokka/site/templates.scala

@@ -64,15 +64,15 @@ case class TemplateFile(
     val layoutTemplate = layout.map(name =>
       ctx.layouts.getOrElse(name, throw new RuntimeException(s"No layouts named $name in ${ctx.layouts}")))
 
-    def asJavaElement(k: String, v: Object): Object = v match 
+    def asJavaElement(o: Object): Object = o match 
       case m: Map[_, _] => m.transform {
-        case (k: String, v: Object) => asJavaElement(k, v)
+        case (k: String, v: Object) => asJavaElement(v)
       }.asJava
-      case l: List[_] => l.asJava
+      case l: List[_] => l.map(x => asJavaElement(x.asInstanceOf[Object])).asJava
       case other => other
 
     // Library requires mutable maps..
-    val mutableProperties = HMap(ctx.properties.transform(asJavaElement).asJava)
+    val mutableProperties = HMap(ctx.properties.transform((_, v) => asJavaElement(v)).asJava)
     val rendered = Template.parse(this.rawCode).render(mutableProperties)
     // We want to render markdown only if next template is html
     val code = if (isHtml || layoutTemplate.exists(!_.isHtml)) rendered else

scala3doc/src/dotty/renderers/ScalaHtmlRenderer.scala

@@ -24,6 +24,7 @@ import dotty.dokka.site.StaticPageNode
 import dotty.dokka.site.PartiallyRenderedContent
 import scala.util.Try
 import org.jetbrains.dokka.base.renderers.html.SearchbarDataInstaller
+import org.jsoup.Jsoup
 
 class SignatureRenderer(pageContext: ContentPage, sourceSetRestriciton: JSet[DisplaySourceSet], locationProvider: LocationProvider):
   def link(dri: DRI): Option[String] = Option(locationProvider.resolve(dri, sourceSetRestriciton, pageContext))
@@ -257,7 +258,26 @@ class ScalaHtmlRenderer(ctx: DokkaContext) extends HtmlRenderer(ctx) {
             .flatMap(dri => Option(getLocationProvider.resolve(dri, sourceSets, page)))
             .getOrElse(str)
 
-        withHtml(context, prc.procsesHtml(url => Try(URL(url)).fold(_ => processLocalLink(url), _ => url)))
+        val childrenContent = page.getChildren.asScala.collect {
+          case p: StaticPageNode => p.getContent.asInstanceOf[PartiallyRenderedContent]//.resolved.code
+        }
+
+        val html = prc.procsesHtml(url => Try(URL(url)).fold(_ => processLocalLink(url), _ => url))
+        val htmlAst = Jsoup.parse(html)
+
+        childrenContent.foreach { c =>
+          val code = Jsoup.parse(c.resolved.code)
+          val brief = code.select("p").first()
+          try {
+            val li = htmlAst.select(s"li:contains(${c.template.title})")
+            val div = li.select(s"div.excerpt")
+            div.html(brief.toString)
+          } catch {
+            _ =>
+          }
+        }
+
+        withHtml(context, htmlAst.toString)
       case content =>
         build(content, context, page, /*sourceSetRestriction=*/null)