.circumflex-markeven.2.0.2.source-code.package.scala Maven / Gradle / Ivy

Go to download
package ru.circumflex

import java.util.Random
import java.util.regex.Pattern
import collection.mutable.HashMap
import core._
import markeven._

/*!# The `markeven` Package

Package `markeven` contains a rendering method for Markeven Processor as well as
utility methods and constants used under the hood.

You should import this package to use Circumflex Markeven in your application:

    import ru.circumflex.markeven._

# Rendering HTML

The `toHtml` method is used to perform text-to-html conversion using default `MarkevenProcessor`.
The usage is pretty simple:

    val text = """                                                {.scala}
    Hello world!              {#hi.greeting.example}
    ============

    This is a test.
    """
    val html = toHtml(text)

The example above yields following HTML:

    Hello world!        {.html}
    This is a test.

You can use your custom `MarkevenProcessor` implementation with rendering methods: just set the
`markeven.processor` configuration parameter to fully-qualified name of your processor implementation.
*/
package object markeven {

  // Rendering stuff

  def processor = cx.instantiate[MarkevenProcessor]("markeven.processor", new MarkevenProcessor)

  def toHtml(source: CharSequence): String = processor.toHtml(source)

  // Utilities

  val chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  val keySize = 20
  val rnd = new Random

  val escapeMap = Map[String, String](
    "\\\\" -> "\",
    "\\`" -> "`",
    "\\_" -> "_",
    "\\*" -> "*",
    "\\{" -> "{",
    "\\}" -> "}",
    "\\[" -> "[",
    "\\]" -> "]",
    "\\(" -> "(",
    "\\)" -> ")",
    "\\#" -> "#",
    "\\+" -> "+",
    "\\-" -> "-",
    "\\~" -> "~",
    "\\." -> ".",
    "\\!" -> "!")

  object regexes {
    val lineEnds = Pattern.compile("\\r\\n|\\r")
    val blankLines = Pattern.compile("^ +$", Pattern.MULTILINE)
    val blocks = Pattern.compile("\\n{2,}")
    val lines = Pattern.compile("\\n")
    val htmlNameExpr = "(?>[a-z][a-z0-9\\-_:.]*+\\b)"
    val inlineHtmlBlockStart = Pattern.compile("^ {0,3}<(" + htmlNameExpr + ")[\\S\\s]*?(/)?>",
      Pattern.CASE_INSENSITIVE | Pattern.MULTILINE)
    val inlineHtmlSpanStart = Pattern.compile("<(" + htmlNameExpr + ")[\\S\\s]*?(/)?>",
      Pattern.MULTILINE | Pattern.CASE_INSENSITIVE)
    val linkDefinition = Pattern.compile("^ {0,3}\\[(.+?)\\]: *(\\S.*?)" +
        "(\\n? *\"(.+?)\")?(?=\\n+|\\Z)", Pattern.MULTILINE)
    val blockSelector = Pattern.compile("(?<=\\A[^\\n]*?) *?\\{(\\#[a-zA-Z0-9_-]+)?((?:\\.[a-zA-Z0-9_-]+)+)?\\}$",
      Pattern.MULTILINE)
    val tableCellSplit = Pattern.compile("\\|")
    val tableSeparatorLine = Pattern.compile("^[- :|]+$")
    val macro = Pattern.compile("\\[\\[((?>[a-zA-Z0-9_-]+:))?(.*?)\\]\\]", Pattern.DOTALL)
    val codeSpan = Pattern.compile("(`++)(.+?)\\1")
    val protectKey = Pattern.compile("!\\}[0-9a-zA-Z]{" + keySize + "}")
    val backslashChar = Pattern.compile("\\\\(\\S)")
    val refLinks = Pattern.compile("\\[([^\\[\\]]*+)\\]\\[([^\\[\\]]*+)\\]")
    val refImages = Pattern.compile("!\\[([^\\[\\]]*+)\\]\\[([^\\[\\]]*+)\\]")
    val inlineLinks = Pattern.compile("\\[([^\\[\\]]*+)\\]\\((.*?)( +\"(.*?)\")?\\)")
    val inlineImages = Pattern.compile("!\\[([^\\[\\]]*+)\\]\\((.*?)( +\"(.*?)\")?\\)")
    val htmlComment = Pattern.compile("^ {0,3}\\s*?(?=\\n+|\\Z)", Pattern.MULTILINE | Pattern.DOTALL)
    val spanEnhancements = Pattern.compile("([*_~])(?=\\S)(.+?)(?<=\\S)\\1")

    // escape patterns

    val e_amp = Pattern.compile("&(?!#?[xX]?[0-9a-zA-Z]+;)")
    val e_lt = Pattern.compile("<(?![a-z/?\\$!])")

    // deterministic patterns

    val d_code = Pattern.compile("(?: {4,}.*\\n?)+")
    val d_div = Pattern.compile("(?: {0,3}\\|.*\\n?)+")
    val d_blockquote = Pattern.compile("(?: {0,3}>.*\\n?)+")
    val d_hr = Pattern.compile("^-{3,} *\\n?$")
    val d_table = Pattern.compile("^-{3,}>?\\n.+\\n *-{3,}\\s*\\n?$", Pattern.DOTALL)
    val d_heading = Pattern.compile("^(\\#{1,6}) (.*) *\\#*$", Pattern.DOTALL)
    val d_h1 = Pattern.compile("^(.+)\\n=+\\n?$", Pattern.DOTALL)
    val d_h2 = Pattern.compile("^(.+)\\n-+\\n?$", Pattern.DOTALL)

    // trimming patterns

    val t_blockquote = Pattern.compile("^ *>", Pattern.MULTILINE)
    val t_div = Pattern.compile("^ *\\|", Pattern.MULTILINE)
    val t_ul = Pattern.compile("^(\\* +)")
    val t_ol = Pattern.compile("^(\\d+\\. +)")
    val t_tr = Pattern.compile("^\\|")

    // list split patterns

    val s_ul = Pattern.compile("\\n+(?=\\* )")
    val s_ol = Pattern.compile("\\n+(?=\\d+\\. )")

    // cache dynamic expressions

    protected val outdentMap = new HashMap[Int, Pattern]
    protected val placeholder = Pattern.compile("^", Pattern.MULTILINE)

    def outdent(level: Int): Pattern = outdentMap.get(level) match {
      case Some(p) => p
      case _ =>
        val p = Pattern.compile("^ {0," + level + "}", Pattern.MULTILINE)
        outdentMap += (level -> p)
        p
    }

    protected val htmlTagMap = new HashMap[String, Pattern]

    protected def htmlTagInternal(tag: String): Pattern = htmlTagMap.get(tag) match {
      case Some(p) => p
      case _ =>
        val p = Pattern.compile("(<" + tag + "\\b.*?(/)?>)|()",
          Pattern.CASE_INSENSITIVE)
        htmlTagMap += tag -> p
        p
    }

    def htmlTag(tag: String): Pattern = htmlTagInternal(tag.toLowerCase)

    // typographic patterns

    val ty_dash = Pattern.compile("--")
    val ty_larr = Pattern.compile("<-|<-")
    val ty_rarr = Pattern.compile("->|->")
    val ty_hellip = Pattern.compile("\\.{3}")
    val ty_trade = Pattern.compile("\\([tT][mM]\\)")
    val ty_reg = Pattern.compile("\\([rR]\\)")
    val ty_copy = Pattern.compile("\\([cC]\\)")
    val ty_ldquo = Pattern.compile("(?<=\\s|\\A)(?:\"|")(?=\\S)")
    val ty_rdquo = Pattern.compile("(?<=[\\p{L})?!.])(?:\"|")(?=[.,;?!*)]|\\s|\\Z)")
  }

  object typographics {
    val dash = cx.get("me.dash").map(_.toString).getOrElse("—")
    val larr = cx.get("me.larr").map(_.toString).getOrElse("←")
    val rarr = cx.get("me.rarr").map(_.toString).getOrElse("→")
    val hellip = cx.get("me.hellip").map(_.toString).getOrElse("…")
    val trade = cx.get("me.trade").map(_.toString).getOrElse("™")
    val reg = cx.get("me.reg").map(_.toString).getOrElse("®")
    val copy = cx.get("me.copy").map(_.toString).getOrElse("©")
    val ldquo = cx.get("me.ldquo").map(_.toString).getOrElse("“")
    val rdquo = cx.get("me.rdquo").map(_.toString).getOrElse("”")
  }
}