dotty.tools.scaladoc.parsers.WikiCodeBlockParser.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scaladoc_3 Show documentation
scaladoc
The newest version!
package dotty.tools.scaladoc.parsers

import com.vladsch.flexmark.ast._
import com.vladsch.flexmark.parser.Parser
import com.vladsch.flexmark.parser.core._
import com.vladsch.flexmark.parser.block._
import com.vladsch.flexmark.util.ast.Block
import com.vladsch.flexmark.util.ast.BlockContent
import com.vladsch.flexmark.util.data.DataHolder
import com.vladsch.flexmark.util.sequence.BasedSequence
import com.vladsch.flexmark.util.sequence.SegmentedSequence

import java.{util => ju}
import ju.regex.Matcher
import ju.regex.Pattern
import scala.jdk.CollectionConverters._


/** Copied from FencedCodeBlockParser. */
object WikiCodeBlockParser {
  private val OPENING_FENCE = Pattern.compile("^\\{{3}")
  private val CLOSING_FENCE = Pattern.compile("^(\\}{3})(?=[ \t]*$)$")

  class Factory extends CustomBlockParserFactory {
    override def apply(options: DataHolder): BlockParserFactory =
      new WikiCodeBlockParser.BlockFactory(options)

    override def getAfterDependents =
      new ju.HashSet[Class[?]](ju.Arrays.asList(
        classOf[BlockQuoteParser.Factory],
        classOf[HeadingParser.Factory],
        //FencedCodeBlockParser.Factory.class,
        //HtmlBlockParser.Factory.class,
        //ThematicBreakParser.Factory.class,
        //ListBlockParser.Factory.class,
        //IndentedCodeBlockParser.Factory.class
      ))

    override def getBeforeDependents =
      new ju.HashSet[Class[?]](ju.Arrays.asList(
        //BlockQuoteParser.Factory.class,
        //HeadingParser.Factory.class,
        //FencedCodeBlockParser.Factory.class,
        classOf[HtmlBlockParser.Factory],
        classOf[ThematicBreakParser.Factory],
        classOf[ListBlockParser.Factory],
        classOf[IndentedCodeBlockParser.Factory],
      ))

    override def affectsGlobalScope = false
  }

  private[WikiCodeBlockParser] class BlockFactory (val options: DataHolder)
  extends AbstractBlockParserFactory(options) {
    def tryStart(state: ParserState, matchedBlockParser: MatchedBlockParser): BlockStart = {
      val nextNonSpace = state.getNextNonSpaceIndex
      val line = state.getLine
      var matcher: Matcher = null
      if state.getIndent < 4 then {
        val trySequence = line.subSequence(nextNonSpace, line.length)
        matcher = OPENING_FENCE.matcher(trySequence)
        if matcher.find then {
          val fenceLength = matcher.group(0).length
          val blockParser =
            new WikiCodeBlockParser(state.getProperties, fenceLength, state.getIndent, nextNonSpace)
          blockParser.block.setOpeningMarker(trySequence.subSequence(0, fenceLength))
          return BlockStart.of(blockParser).atIndex(nextNonSpace + fenceLength)
        }
      }
      BlockStart.none
    }
  }
}

/** Copied from FencedCodeBlockParser. */
class WikiCodeBlockParser(
  options: DataHolder,
  var fenceLength: Int,
  private var fenceIndent: Int,
  private var fenceMarkerIndent: Int
) extends AbstractBlockParser {

  this.fenceMarkerIndent = fenceIndent + fenceMarkerIndent

  final private val block = new FencedCodeBlock()
  private var content = new BlockContent
  private val codeContentBlock = Parser.FENCED_CODE_CONTENT_BLOCK.get(options)

  def getBlock: Block = block
  def getFenceIndent: Int = fenceIndent
  def getFenceMarkerIndent: Int = fenceMarkerIndent
  def tryContinue(state: ParserState): BlockContinue = {
    val nextNonSpace = state.getNextNonSpaceIndex
    var newIndex = state.getIndex
    val line = state.getLine
    var matcher: Matcher = null
    val matches =
      state.getIndent <= 3
      && nextNonSpace < line.length

    if matches then {
      val trySequence = line.subSequence(nextNonSpace, line.length)
      matcher = WikiCodeBlockParser.CLOSING_FENCE.matcher(trySequence)
      if matcher.find then {
        val foundFenceLength = matcher.group(0).length
        if (foundFenceLength >= fenceLength) { // closing fence - we're at end of line, so we can finalize now
          block.setClosingMarker(trySequence.subSequence(0, foundFenceLength))
          return BlockContinue.finished
        }
      }
    }
    // skip optional spaces of fence indent
    var i = fenceIndent
    while ({
      i > 0 && newIndex < line.length && line.charAt(newIndex) == ' '
    }) do {
      newIndex += 1
      i -= 1
    }
    BlockContinue.atIndex(newIndex)
  }

  override def addLine(state: ParserState, line: BasedSequence): Unit = {
    content.add(line, state.getIndent)
  }

  override def isPropagatingLastBlankLine(lastMatchedBlockParser: BlockParser) = false

  override def closeBlock(state: ParserState): Unit = { // first line, if not blank, has the info string
    val lines = content.getLines
    if (lines.size > 0) {
      val info = lines.get(0)
      if (!info.isBlank) block.setInfo(info.trim)
      val chars = content.getSpanningChars
      val spanningChars = chars.baseSubSequence(chars.getStartOffset, lines.get(0).getEndOffset)
      if (lines.size > 1) { // have more lines
        val segments = lines.subList(1, lines.size)
        block.setContent(spanningChars, segments)
        if this.codeContentBlock then {
          val codeBlock = new CodeBlock()
          codeBlock.setContent(segments)
          codeBlock.setCharsFromContent
          block.appendChild(codeBlock)
        } else {
          val codeBlock = new Text(SegmentedSequence.create(segments.asScala.toSeq*))
          block.appendChild(codeBlock)
        }
      }
      else block.setContent(spanningChars, BasedSequence.EMPTY_LIST)
    }
    else block.setContent(content)
    block.setCharsFromContent
    content = null
  }
}