markdown2.ometajs

var block_tags = {
    'p':'p',
    'ul':'ul',
    'li':'li',
    'h1':'h1',
    'h2':'h2',
    'h3':'h3',
    'aside':'aside',
    'codeblock':'codeblock'
}

var inline_tags = {
    'b':'b',
    'i':'i',
    'code':'code'
}

var inside = {};
var linkmap = {};
var sections = {};

function fillReferenceLink(id, link) {
    linkmap[id] = link;
}


function escapeRegExp(string) {
    return string.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

function replaceAll(string, find, replace) {
  return string.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}



export ometa Markdown {
    nonEOL    = (~'\n' anything):x -> x,
    toEOL     = (~'\n' anything)*:x '\n' -> x.join(""),
    uptoEOL   = (~'\n' anything)*:x -> x.join(""),
    ws        = (' ')*,
    ws2       = (' '|'\n')*,
    word      = (letter | digit)+:x -> x.join(""),
    EOL       = '\n',
    pairB     = '[' (~']' anything)*:x ']' -> x.join(""),
    pairP     = '(' (~')' anything)*:x ')' -> x.join(""),
    classname = '.' word:clss -> clss,
    keyvaluepair = ws2 word:key ws2 ':' ws2 uptoEOL:value '\n' -> {return {key:key,value:value} },
    keyvaluepairs = (keyvaluepair)+:kvps,

    //block styles
    elem      = '\n' '*' ws uptoEOL:text -> this.listItem(text),
    elem      = '\n' "{" JSONish.start:out "}" -> this.insertCustomBlock(out),
    elem      = "```" ws (word)?:id toEOL:params (~"```" anything)+:text "```" -> this.insertCodeBlock(text.join(''),id,params),
    elem      = '\n' '#' '#' '#' ws uptoEOL:text -> this.header(1,text),
    elem      = '\n' '#' '#' ws uptoEOL:text -> this.header(2,text),
    elem      = '\n' '#' ws uptoEOL:text -> this.header(3,text),
    elem      = '\n' '[' word:id ']' ':' toEOL:link -> fillReferenceLink(id, link),
    elem      = '\n' "---" -> this.horizontalRule(),

    //inline styles
    elem      = '*' -> this.toggle('b'),
    elem      = '_' -> this.toggle('i'),
    elem      = '`' -> this.toggle('code'),
    elem      = '!' pairB:title pairP:link classname?:cname -> this.insertInlineImage(title,link,cname),
    elem      = pairB:title pairP:link -> this.insertInlineLink(title,link),
    elem      = pairB:title pairB:link -> this.insertReferenceLink(title,link),
    elem      = EOL "@note" -> this.openNoteParagraph(),
    elem      = EOL &EOL -> this.openBlock('p'),

    //plain text
    elem      = anything:x -> this.append(x),
    start     =  elem+ anything*:y -> this.endBody(y)
}

Markdown.openNoteParagraph = function() {
    this.openBlock('aside',{class:'notes'});
}
Markdown.reset = function() {
    this.buffer = "";
    inside = {};
    linkmap = {};
    sections = {};
}

Markdown.append = function(text) {
    this.buffer += text;
}

Markdown.open = function(tag, atts) {
    if(tag == 'codeblock') {
        this.append('<pre><code>');
        return;
    }
    this.append('<'+tag);
    for(var key in atts) {
        this.append(' '+key+'="'+atts[key]+'"');
    }
    this.append('>');
}

Markdown.close = function(tag) {
    if(tag == 'codeblock') {
        this.append('</code></pre>');
        return;
    }
    this.append('</'+tag+'>');
}

Markdown.closeBlock = function(n) {
    this.close(n);
    this.append('\n');
    inside[n] = false;
}



Markdown.closeAll = function() {
    for(var elem in block_tags) {
        if(inside[elem]) {
            this.append('\n');
            this.close(elem);
            inside[elem] = false;
            this.append('\n');
        }
    };
    for(var elem in inline_tags) {
        if(inside[elem]) {
            this.close(elem);
            inside[elem] = false;
        }
    };
}

Markdown.openBlock = function(n, atts) {
    this.closeAll();
    inside[n] = true;
    this.append('\n');
    this.open(n,atts);
}

Markdown.toggle = function(n) {
    if(!inside[n]) {
        inside[n] = false;
    }

    if(inside[n]) {
        inside[n] = false;
        this.close(n);
    } else {
        inside[n] = true;
        this.open(n);
    }
}

Markdown.toggleBlock = function(n) {
    if(!inside[n]) {
        inside[n] = false;
    }
    if(inside[n]) {
        inside[n] = false;
        this.close(n);
    } else {
        inside[n] = true;
        this.open(n);
    }
}


Markdown.endBody = function(y) {
    this.closeAll();
    return {
        content: this.buffer.toString(),
        sections: sections,
        linkmap: linkmap
    }
}

Markdown.insertInlineLink = function(text, href) {
    this.append("<a href='"+href+"'>");
    this.append(text);
    this.close('a');
}
Markdown.insertReferenceLink = function(text, ref) {
    this.append("<a href='#' id='"+ref+"'>");
    this.append(text);
    this.close('a');
}

Markdown.insertCodeBlock = function(text, id,params) {
    this.closeAll();
    if(id) {
        this.codeblocks[id] = text;
    } else {
        this.append("<pre><code>");
        this.append(replaceAll(text,'<','&lt;'));
        this.append("</code></pre>");
    }
}

Markdown.insertCustomBlock = function (params) {
    console.log("type = ", params.type);
    if(Markdown.customProcessors[params.type]) {
        var self = this;
        Markdown.customProcessors[params.type](function(text) {self.append(text) }, params);
        return;
    }
}

Markdown.insertInlineImage = function(text, href,cname) {
    if(Markdown.classProcessors[cname]) {
        var self = this;
        Markdown.classProcessors[cname](function(text) {self.append(text) }, text, href);
        return;
    }
    this.append("<img src='"+href+"' alt='"+text+"'");
    if(cname) {
        this.append(" class='"+cname+"'");
    }
    this.append("/>");
}

Markdown.classProcessors = {};
Markdown.customProcessors = {};
Markdown.codeblocks = {};


Markdown.listItem = function(text) {
    if(!inside['ul']) this.openBlock('ul');
    this.append("<li>"+text+"</li>\n");
}

Markdown.header = function(level, text) {
    var id = 'id'+Math.floor(Math.random()*100000);
    sections[id] = {
        level: level,
        text: text
    };
    this.openBlock('h'+level, {id:id});
    this.append(text);
    this.closeBlock('h'+level);
}

Markdown.horizontalRule = function() {
    this.append("<hr/>");

    this.closeAll();
    this.append('\n');
}

function smoosh(arr) {
    var obj = {};
    arr.forEach(function(kv){
        obj[kv[0]] = kv[1];
    });
    return obj;
}

export ometa JSONish {
    word      = (letter|digit)+:x -> x.join(''),
    number    = digit+:x -> x.join(''),
    qstring   = ws '"' (~'"' anything)*:x '"' -> x.join(''),
    ws        = (' '|'\n')*,
    key       = word,
    object    = qstring:t ',' ws -> t,
    array     = "[" object*:vals "]" -> vals,

    value     = (digit+):x -> x.join(''), // number
    value     = qstring,                  // quoted string
    value     = ws array:arr ws -> arr,   // array of values
    value     = ws "{" keypair*:pairs "}" -> smoosh(pairs), // key value pairs

    keypair   =  ws key:k ":" ws value:v ','? -> [k,v],
    start     =  "{" keypair+:kps ws "}" -> smoosh(kps)
}