Removing nested blocks from a string

As Illya has mentioned Regex alone cannot solve this problem. Instead, we must employ some type of stack-like data structure to give our program memory of past characters. The first three lines of the main function are just a cheap way to replace blockers with a single character. A better solution would be to tokenize txt so that this isn't necessary.

def removeBlocks(txt: String, startBlocker: String, endBlocker: String): String = {
  val left = "["
  val right = "]"
  val filteredTxt = txt.replace(startBlocker, left).replace(endBlocker, right)

  def func(xs: List[String], stk: List[String]): List[String] = xs match {
    case Nil => Nil
    case `left` :: tail  => func(tail, left :: stk)
    case `right` :: tail => func(tail, stk.tail)
    case head :: tail =>
      if (stk.nonEmpty && stk.head == left) 
        func(tail, stk)
      else 
        head :: func(tail, stk)
  }

  func((filteredTxt map(_.toString)).toList, Nil).mkString
}

I think you are trying to do some pattern matching on strings.

So I did this:

def escape(s: String): String = Seq("{", "}", "whatever").foldLeft(s)((x, y) => x.replaceAllLiterally(y, "\\" + y))

def removeBlocks(text: String, open: String, close: String): String = {
    val startReg = (s"${escape(open)}(.*)$$").r
    val endReg = (s"${escape(close)}(.*)$$").r
    val otherText = "(.)(.*)$".r

    @tailrec
    def removeBlocksAux(text: String, acc: String = "", lvl: Int = 0): String = {
        assume((text.length() > 0 || lvl == 0) && lvl >= 0)
        (text, lvl) match {
            case (startReg(text), lvl)     => removeBlocksAux(text, acc, lvl + 1)
            case (endReg(text), lvl)       => removeBlocksAux(text, acc, lvl - 1)
            case (otherText(c, text), 0)   => removeBlocksAux(text, acc + c)
            case (otherText(c, text), lvl) => removeBlocksAux(text, acc, lvl)
            case ("", _)                   => acc
        }
    }
    removeBlocksAux(text)
}

I tried to find a way to define the regular expressions inside the match group, but I failed at that, it may not be a good idea after all, but I would like to have a more compact and efficient representation for it. The escape function should escape all special cases of operators in Scala regex, that sounds boring, so there may be already a method for that.

I'm also not a big fan of having a function inside a function, but I kept that design decision. Finally, I'd simply use parser combinators for this, but I guess that's not the point.

The simplest thing that comes to mind, provided you're willing to escape special regex chars (like the braces in your examples) yourself (or use Apache Commons, see below) would be this:

def removeBlocks(text: String, startMarker: String, endMarker: String) = {
  val pattern = s"${startMarker}(.*)${endMarker}"
  text.replaceAll(pattern, "")
}

scala> removeBlocks("123<div>456</div>789", "<div>", "</div>")
res20: String = 123789

scala> removeBlocks("123{456}789", "\\{", "\\}")
res19: String = 123789

If you were willing to use Apache Commons, commons lang has StringEscapeUtils which you could use to remove that issue.