benches/markdown: introduces markdown benches

[nit.git] / benchmarks / markdown / benches / gen_benches.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Generate bench suites for markdown parsers.
module gen_benches

import opts

# Decorate a markdown plain text for bench puposes.
#
# *This is not the markdown you are looking for.*
interface MarkdownDecorator

        # Parse the text and decorate it.
        # Behavior depends on `LineDecorator` and `WordDecorator`.
        fun decorate_text(txt: Text): Text is abstract

        # Is `c` a something else than a letter a digit or a `-`?
        fun is_word_break(c: Char): Bool do
                return not (c.is_letter or c.is_digit or c == '-')
        end

        # Parses the next word from `pos` and return the ending position.
        # Returns `-1` if next word is a word break symbol or there is no more text.
        private fun parse_word(txt: Text, pos: Int, res: FlatBuffer): Int do
                while pos >= 0 and pos < txt.length do
                        var c = txt[pos]
                        if is_word_break(c) then break
                        res.add c
                        pos += 1
                end
                return pos
        end
end

# Break text in lines of ~80 chars and call `decorate_line` for each.
abstract class LineDecorator
        super MarkdownDecorator

        redef fun decorate_text(txt) do return decorate_lines(txt)

        private fun decorate_lines(txt: Text): Text do
                var pos = 0
                var res = new FlatBuffer
                var line = new FlatBuffer
                var word = new FlatBuffer
                while pos < txt.length do
                        var c = txt[pos]
                        if is_word_break(c) then
                                pos += 1
                                line.add c
                                if c == '\n' then
                                        res.append decorate_line(line)
                                        line.clear
                                end
                        else
                                pos = parse_word(txt, pos, word)
                                if line.length + word.length > 80 then
                                        res.append decorate_line(line)
                                        line.clear
                                end
                                line.append word
                                word.clear
                        end
                end
                return res
        end

        # Returns the decorated version of `line`.
        fun decorate_line(line: Text): Text is abstract
end

# Add a `\n` after each line.
class ManualBreakDecorator
        super LineDecorator

        redef fun decorate_line(line) do return "{line}\n"
end

# Add a `> ` before each line.
class BlockQuoteDecorator
        super ManualBreakDecorator

        redef fun decorate_line(line) do return super("> {line}")
end

# Add four spaces before each line.
class CodeBlockDecorator
        super ManualBreakDecorator

        redef fun decorate_line(line) do return super("    {line}")
end

# Add "* " before each line.
class UnorderedListDecorator
        super ManualBreakDecorator

        redef fun decorate_line(line) do return super("* {line}")
end


# WordDecorator is used to decorate each word of a text.
abstract class WordDecorator
        super MarkdownDecorator

        redef fun decorate_text(txt): Text do return decorate_words(txt)

        private fun decorate_words(txt: Text): Text do
                var pos = 0
                var res = new FlatBuffer
                var tmp = new FlatBuffer
                while pos < txt.length do
                        var c = txt[pos]
                        if is_word_break(c) then
                                pos += 1
                                res.add c
                        else
                                pos = parse_word(txt, pos, tmp)
                                res.append decorate_word(tmp)
                                tmp.clear
                        end
                end
                return res
        end

        # Returns the decorated version of `word`.
        fun decorate_word(word: Text): Text is abstract
end

# Returns the word as this.
class PlainDecorator
        super WordDecorator

        redef fun decorate_word(word) do return word
end

# Wraps the word with `*empthasis*`.
class EmphasisDecorator
        super WordDecorator

        redef fun decorate_word(w) do return "*{w}*"
end

# Wraps the word with `**strong**`.
class StrongDecorator
        super WordDecorator

        redef fun decorate_word(w) do return "**{w}**"
end

# Wraps the word with ````inline code````.
class InlineCodeDecorator
        super WordDecorator

        redef fun decorate_word(w) do return "`{w}`"
end

# Wraps the word with `<fastlink>`.
class FastLinkDecorator
        super WordDecorator

        redef fun decorate_word(w) do return "<{w}>"
end

# Replaces the word letters by random special XML chars.
class SpecialXmlCharsDecorator
        super WordDecorator

        # Random chars used
        var chars: Array[Char] = ['<', '>', '&']

        redef fun decorate_word(w) do
                var res = new FlatBuffer
                for c in w do
                        var i = chars.length.rand
                        res.add chars[i]
                end
                return res
        end
end

# Wraps the word with `<blink>inline html<block>`.
class InlineHtmlDecorator
        super WordDecorator

        redef fun decorate_word(w) do return "<blink>{w}</blink>"
end

# Replaces the word with `[link](htt://example.com/link "link Title")`.
class FullLinkDecorator
        super WordDecorator

        redef fun decorate_word(w) do
                return "[{w}](http://example.com/{w} \"{w} Title\")"
        end
end

# Replaces the word with `![link](htt://example.com/link "link Title")`.
class FullImageDecorator
        super WordDecorator

        redef fun decorate_word(w) do
                return "![{w}](http://example.com/{w} \"{w} Title\")"
        end
end

# Replaces the word with `[reflink][id123]`.
class RefLinkDecorator
        super WordDecorator

        redef fun decorate_word(w) do
                return "[{w}][id123]"
        end
end

# Uses other decorators randomly.
class MixedDecorator
        super LineDecorator
        super WordDecorator

        redef fun decorate_text(txt) do
                return decorate_lines(txt)
        end

        private var line_decs: Array[LineDecorator] is lazy do
                return [new ManualBreakDecorator, new BlockQuoteDecorator,
                new CodeBlockDecorator, new UnorderedListDecorator: LineDecorator]
        end

        private var current_dec: LineDecorator = line_decs.first is lazy

        redef fun decorate_line(line) do
                var re = "\n$".to_re
                var txt = current_dec.decorate_line(line)
                if line.has(re) then
                        var i = line_decs.length.rand
                        current_dec = line_decs[i]
                end
                return decorate_words(txt)
        end

        private var word_decs: Array[WordDecorator] is lazy do
                return [new PlainDecorator, new EmphasisDecorator, new StrongDecorator,
                new InlineCodeDecorator, new FastLinkDecorator, new SpecialXmlCharsDecorator,
                new InlineHtmlDecorator, new FullLinkDecorator, new FullImageDecorator,
                new RefLinkDecorator: WordDecorator]
        end

        redef fun decorate_word(w) do
                var i = word_decs.length.rand
                return word_decs[i].decorate_word(w)
        end
end

var opt_dir = new OptionString("Output directory", "-o", "--output")
var ctx = new OptionContext
ctx.add_option(opt_dir)
ctx.parse(args)

if ctx.rest.length != 1 then
        print "Usage:"
        print "gen_benches path/to/base/text.md"
        exit 0
end

var out_dir = opt_dir.value or else "markdown.out/"
out_dir.mkdir

var txt = ctx.rest.first.to_path.read_all

var lst = [new ManualBreakDecorator, new BlockQuoteDecorator, new CodeBlockDecorator,
                new UnorderedListDecorator, new MixedDecorator, new EmphasisDecorator,
                new StrongDecorator, new InlineCodeDecorator, new FastLinkDecorator,
                new SpecialXmlCharsDecorator, new InlineHtmlDecorator, new FullLinkDecorator,
                new FullImageDecorator, new RefLinkDecorator: MarkdownDecorator]

for dec in lst do
        var name = dec.class_name.to_snake_case.basename("_decorator")
        dec.decorate_text(txt).write_to_file("{out_dir}/{name}.md")
end