convert public case classes in laika.rewrite.nav (#491)

Author: jenshalm

core/shared/src/main/scala/laika/ast/documents.scala

@@ -58,7 +58,7 @@ sealed trait TreeContent extends Navigatable {
     config.get[Traced[String]](LaikaKeys.title).toOption.flatMap { tracedTitle =>
       if (tracedTitle.origin.scope == configScope) {
         val title             = Seq(Text(tracedTitle.value))
-        val autonumberConfig  = config.get[AutonumberConfig].getOrElse(AutonumberConfig.defaults)
+        val autonumberConfig  = config.get[AutonumberConfig].getOrElse(AutonumberConfig.disabled)
         val autonumberEnabled =
           autonumberConfig.documents && position.depth < autonumberConfig.maxDepth
         if (autonumberEnabled) Some(SpanSequence(position.toSpan +: title))

core/shared/src/main/scala/laika/rewrite/nav/AutonumberConfig.scala

@@ -16,45 +16,39 @@
 
 package laika.rewrite.nav
 
-import laika.config.{
-  Config,
-  ConfigBuilder,
-  ConfigDecoder,
-  ConfigEncoder,
-  DefaultKey,
-  Key,
-  LaikaKeys,
-  ValidationError
-}
+import laika.config.*
 
 /** Configuration for autonumbering of documents and sections.
   */
-case class AutonumberConfig(
-    documents: Boolean = true,
-    sections: Boolean = true,
-    maxDepth: Int = Int.MaxValue
-)
+sealed abstract class AutonumberConfig {
 
-private[nav] sealed trait Scope
+  /** Applies autonumbering to directories and documents and their titles. */
+  def documents: Boolean
 
-private[nav] object Scope {
-  case object Documents extends Scope
-  case object Sections  extends Scope
-  case object All       extends Scope
-  case object None      extends Scope
+  /** Applies autonumber to section header within documents. */
+  def sections: Boolean
 
-  implicit val decoder: ConfigDecoder[Scope] = ConfigDecoder.string.flatMap {
-    case "documents" => Right(Documents)
-    case "sections"  => Right(Sections)
-    case "all"       => Right(All)
-    case "none"      => Right(None)
-    case other       => Left(ValidationError(s"Invalid value for autonumbering.scope: $other"))
-  }
+  /** Specifies how many levels deep the autonumbering should be applied.
+    * Any documents or section headers beyond this limit will be ignored.
+    *
+    * The default is unlimited depth.
+    */
+  def maxDepth: Int
 
+  /** Specifies how many levels deep the autonumbering should be applied.
+    * Any documents or section headers beyond this limit will be ignored.
+    */
+  def withMaxDepth(value: Int): AutonumberConfig
 }
 
 object AutonumberConfig {
 
+  private final case class Impl(documents: Boolean, sections: Boolean, maxDepth: Int)
+      extends AutonumberConfig {
+    override def productPrefix: String             = "AutonumberConfig"
+    def withMaxDepth(value: Int): AutonumberConfig = copy(maxDepth = value)
+  }
+
   private val scopeKey = Key("scope")
   private val depthKey = Key("depth")
 
@@ -71,7 +65,7 @@ object AutonumberConfig {
         case Scope.All       => (true, true)
         case Scope.None      => (false, false)
       }
-      AutonumberConfig(documents, sections, depth)
+      Impl(documents, sections, depth)
     }
   }
 
@@ -92,7 +86,9 @@ object AutonumberConfig {
   /** Disables section numbering for the specified config instance.
     * Retains the existing value for auto-numbering of documents.
     */
-  def withoutSectionNumbering(config: Config)(builder: ConfigBuilder): ConfigBuilder = {
+  private[laika] def withoutSectionNumbering(
+      config: Config
+  )(builder: ConfigBuilder): ConfigBuilder = {
     val key = LaikaKeys.autonumbering.child(scopeKey)
     config.get[Scope](key).toOption.fold(builder) {
       case Scope.Documents => builder
@@ -102,10 +98,43 @@ object AutonumberConfig {
     }
   }
 
-  /** The defaults for autonumbering with section
-    *  and document numbering both switched off.
+  /** Section numbering within documents switched on, but document and directory numbering switched off.
+    */
+  def sectionsEnabled: AutonumberConfig =
+    Impl(documents = false, sections = true, maxDepth = Int.MaxValue)
+
+  /** Document and directory numbering switched on, but section numbering within documents switched off.
+    */
+  def documentsEnabled: AutonumberConfig =
+    Impl(documents = true, sections = false, maxDepth = Int.MaxValue)
+
+  /** Section and document numbering both switched on.
     */
-  def defaults: AutonumberConfig =
-    AutonumberConfig(documents = false, sections = false, maxDepth = 0)
+  def allEnabled: AutonumberConfig =
+    Impl(documents = true, sections = true, maxDepth = Int.MaxValue)
+
+  /** Section and document numbering both switched off.
+    */
+  def disabled: AutonumberConfig =
+    Impl(documents = false, sections = false, maxDepth = 0)
+
+}
+
+private[nav] sealed trait Scope
+
+private[nav] object Scope {
+
+  case object Documents extends Scope
+  case object Sections  extends Scope
+  case object All       extends Scope
+  case object None      extends Scope
+
+  implicit val decoder: ConfigDecoder[Scope] = ConfigDecoder.string.flatMap {
+    case "documents" => Right(Documents)
+    case "sections"  => Right(Sections)
+    case "all"       => Right(All)
+    case "none"      => Right(None)
+    case other       => Left(ValidationError(s"Invalid value for autonumbering.scope: $other"))
+  }
 
 }

core/shared/src/main/scala/laika/rewrite/nav/CoverImage.scala

@@ -29,18 +29,27 @@ import laika.config.{ Config, ConfigDecoder, ConfigEncoder, Key, LaikaKeys }
   *
   * @author Jens Halm
   */
-case class CoverImage(path: Path, classifier: Option[String] = None)
+sealed abstract class CoverImage {
+  def path: Path
+  def classifier: Option[String]
+}
 
 object CoverImage {
 
-  def apply(path: Path, classifier: String): CoverImage = CoverImage(path, Some(classifier))
+  private final case class Impl(path: Path, classifier: Option[String] = None) extends CoverImage {
+    override def productPrefix: String = "CoverImage"
+  }
+
+  def apply(path: Path): CoverImage = Impl(path, None)
+
+  def apply(path: Path, classifier: String): CoverImage = Impl(path, Some(classifier))
 
   implicit val decoder: ConfigDecoder[CoverImage] = ConfigDecoder.config.flatMap { config =>
     for {
       path       <- config.get[Path]("path")
       classifier <- config.getOpt[String]("classifier")
     } yield {
-      CoverImage(path, classifier)
+      Impl(path, classifier)
     }
   }
 
@@ -80,7 +89,7 @@ private[laika] object CoverImages {
         .map(_.orElse(classified.find(_.classifier.isEmpty).map(_.path)))
     } yield {
       val classifiedMap = classified
-        .collect { case CoverImage(path, Some(classifier)) => (classifier, path) }
+        .collect { case c: CoverImage if c.classifier.nonEmpty => (c.classifier.get, c.path) }
         .toMap
       CoverImages(default, classifiedMap)
     }

core/shared/src/main/scala/laika/rewrite/nav/PathTranslator.scala

@@ -92,7 +92,9 @@ object PathTranslator {
     */
   def ignoreVersions(translator: PathTranslator): PathTranslator = translator match {
     case cpt: ConfigurablePathTranslator =>
-      cpt.copy(targetLookup = cpt.targetLookup.andThen(_.map(_.copy(isVersioned = false))))
+      cpt.copy(targetLookup =
+        cpt.targetLookup.andThen(_.map(attr => PathAttributes(attr.isStatic, isVersioned = false)))
+      )
     case other                           => other
   }
 
@@ -186,7 +188,19 @@ private[laika] case class ConfigurablePathTranslator(
   def forReferencePath(path: Path): PathTranslator = copy(refPath = path)
 }
 
-case class PathAttributes(isStatic: Boolean, isVersioned: Boolean)
+sealed abstract class PathAttributes {
+  def isStatic: Boolean
+  def isVersioned: Boolean
+}
+
+object PathAttributes {
+
+  private final case class Impl(isStatic: Boolean, isVersioned: Boolean) extends PathAttributes {
+    override def productPrefix = "PathAttributes"
+  }
+
+  def apply(isStatic: Boolean, isVersioned: Boolean): PathAttributes = Impl(isStatic, isVersioned)
+}
 
 private[laika] case class TranslatorConfig(
     versions: Option[Versions],
@@ -243,8 +257,9 @@ private[laika] class TargetLookup(cursor: RootCursor) extends (Path => Option[Pa
     (markupDocs ++ staticDocs).toMap
   }
 
-  val versionedDocuments: Seq[Path] = lookup.collect { case (path, PathAttributes(false, true)) =>
-    path
+  val versionedDocuments: Seq[Path] = lookup.collect {
+    case (path, attr) if attr.isVersioned && !attr.isStatic =>
+      path
   }.toSeq
 
   def apply(path: Path): Option[PathAttributes] =

core/shared/src/main/scala/laika/rewrite/nav/SectionBuilder.scala

@@ -17,7 +17,7 @@
 package laika.rewrite.nav
 
 import laika.ast.RewriteRules.RewriteRulesBuilder
-import laika.ast._
+import laika.ast.*
 import laika.collection.Stack
 import laika.config.Config.ConfigResult
 import laika.config.LaikaKeys
@@ -124,7 +124,7 @@ private[laika] object SectionBuilder extends RewriteRulesBuilder {
     */
   def apply(cursor: DocumentCursor): ConfigResult[RewriteRules] = for {
     autonumbering      <- cursor.config.getOpt[AutonumberConfig].map(
-      _.getOrElse(AutonumberConfig.defaults)
+      _.getOrElse(AutonumberConfig.disabled)
     )
     firstHeaderAsTitle <- cursor.config.get(
       LaikaKeys.firstHeaderAsTitle,