lounge_lizard 0.1.0

data/ext/drafter/ext/snowcrash/ext/markdown-parser/src/MarkdownNode.cc

@@ -0,0 +1,152 @@
+//
+//  MarkdownNode.cc
+//  markdownparser
+//
+//  Created by Zdenek Nemec on 4/19/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "MarkdownNode.h"
+
+using namespace mdp;
+
+MarkdownNode::MarkdownNode(MarkdownNodeType type_, MarkdownNode *parent_, const ByteBuffer& text_, const Data& data_)
+: type(type_), text(text_), data(data_), m_parent(parent_)
+{
+    m_children.reset(::new MarkdownNodes);
+}
+                     
+MarkdownNode::MarkdownNode(const MarkdownNode& rhs)
+{
+    this->type = rhs.type;
+    this->text = rhs.text;
+    this->data = rhs.data;
+    this->sourceMap = rhs.sourceMap;
+    this->m_children.reset(::new MarkdownNodes(*rhs.m_children.get()));
+    this->m_parent = rhs.m_parent;
+}
+
+MarkdownNode& MarkdownNode::operator=(const MarkdownNode& rhs)
+{
+    this->type = rhs.type;
+    this->text = rhs.text;
+    this->data = rhs.data;
+    this->sourceMap = rhs.sourceMap;
+    this->m_children.reset(::new MarkdownNodes(*rhs.m_children.get()));
+    this->m_parent = rhs.m_parent;
+    return *this;
+}
+
+MarkdownNode::~MarkdownNode()
+{
+}
+
+MarkdownNode& MarkdownNode::parent()
+{
+    if (!hasParent())
+        throw "no parent set";
+    return *m_parent;
+}
+
+const MarkdownNode& MarkdownNode::parent() const
+{
+    if (!hasParent())
+        throw "no parent set";
+    return *m_parent;
+}
+
+void MarkdownNode::setParent(MarkdownNode *parent)
+{
+    m_parent = parent;
+}
+
+bool MarkdownNode::hasParent() const
+{
+    return (m_parent != NULL);
+}
+
+MarkdownNodes& MarkdownNode::children()
+{
+    if (!m_children.get())
+        throw "no children set";
+    
+    return *m_children;
+}
+
+const MarkdownNodes& MarkdownNode::children() const
+{
+    if (!m_children.get())
+        throw "no children set";
+    
+    return *m_children;
+}
+
+void MarkdownNode::printNode(size_t level) const
+{
+    using std::cout;
+    for (size_t i = 0; i < level; ++i)
+        std::cout << "  ";
+    
+    cout << "+ ";
+    switch (type) {
+        case RootMarkdownNodeType:
+            cout << "root";
+            break;
+
+        case CodeMarkdownNodeType:
+            cout << "code";
+            break;
+            
+        case QuoteMarkdownNodeType:
+            cout << "quote";
+            break;
+
+        case HTMLMarkdownNodeType:
+            cout << "HTML";
+            break;
+
+        case HeaderMarkdownNodeType:
+            cout << "header";
+            break;
+
+        case HRuleMarkdownNodeType:
+            cout << "hrul";
+            break;
+
+        case ListItemMarkdownNodeType:
+            cout << "list item";
+            break;
+
+        case ParagraphMarkdownNodeType:
+            cout << "paragraph";
+            break;
+            
+        default:
+            cout << "undefined";
+            break;
+    }
+    
+    cout << " (type " << type << ", data " << data << ") - ";
+    cout << "`" << text << "`";
+    
+    if (!sourceMap.empty()) {
+        for (mdp::BytesRangeSet::const_iterator it = sourceMap.begin();
+             it != sourceMap.end();
+             ++it) {
+            std::cout << ((it == sourceMap.begin()) ? " :" : ";");
+            std::cout << it->location << ":" << it->length;
+        }
+    }
+    
+    cout << std::endl;
+    
+    for (MarkdownNodeIterator it = m_children->begin();
+         it != m_children->end();
+         ++it) {
+        it->printNode(level + 1);
+    }
+    
+    if (level == 0)
+        cout << std::endl << std::endl;
+}
+

data/ext/drafter/ext/snowcrash/ext/markdown-parser/src/MarkdownNode.h

@@ -0,0 +1,103 @@
+//
+//  MarkdownNode.h
+//  markdownparser
+//
+//  Created by Zdenek Nemec on 4/16/14.
+//  Copyright (c) 2014 Apiary. All rights reserved.
+//
+
+#ifndef MARKDOWNPARSER_NODE_H
+#define MARKDOWNPARSER_NODE_H
+
+#include <deque>
+#include <memory>
+#include <iostream>
+#include "ByteBuffer.h"
+
+namespace mdp {
+
+    /**
+     *  AST block node types
+     */
+    enum MarkdownNodeType {
+        RootMarkdownNodeType = 0,
+        CodeMarkdownNodeType,
+        QuoteMarkdownNodeType,
+        HTMLMarkdownNodeType,
+        HeaderMarkdownNodeType,
+        HRuleMarkdownNodeType,
+        ListItemMarkdownNodeType,
+        ParagraphMarkdownNodeType,
+        TableMarkdownNodeType,
+        TableRowMarkdownNodeType,
+        TableCellMarkdownNodeType,
+        UndefinedMarkdownNodeType = -1
+    };
+
+    /* Forward declaration of AST Node */
+    class MarkdownNode;
+
+    /** Markdown AST nodes collection */
+    typedef std::deque<MarkdownNode> MarkdownNodes;
+
+    /**
+     *  AST node
+     */
+    class MarkdownNode {
+    public:
+        typedef int Data;
+
+        /** Node type */
+        MarkdownNodeType type;
+
+        /** Textual content, where applicable */
+        ByteBuffer text;
+
+        /** Additinonal data, if applicable */
+        Data data;
+
+        /** Source map of the node including any and all children */
+        BytesRangeSet sourceMap;
+
+        /** Parent node, throws exception if no parent is defined */
+        MarkdownNode& parent();
+        const MarkdownNode& parent() const;
+
+        /** Sets parent node */
+        void setParent(MarkdownNode *parent);
+
+        /** True if section's parent is specified, false otherwise */
+        bool hasParent() const;
+
+        /** Children nodes */
+        MarkdownNodes& children();
+        const MarkdownNodes& children() const;
+
+        /** Constructor */
+        MarkdownNode(MarkdownNodeType type_ = UndefinedMarkdownNodeType,
+                MarkdownNode *parent_ = NULL,
+                const ByteBuffer& text_ = ByteBuffer(),
+                const Data& data_ = Data());
+
+        /** Copy constructor */
+        MarkdownNode(const MarkdownNode& rhs);
+
+        /** Assignment operator */
+        MarkdownNode& operator=(const MarkdownNode& rhs);
+
+        /** Destructor */
+        ~MarkdownNode();
+
+        /** Prints the node to the stdout */
+        void printNode(size_t level = 0) const;
+
+    private:
+        MarkdownNode* m_parent;
+        std::unique_ptr<MarkdownNodes> m_children;
+    };
+
+    /** Markdown AST nodes collection iterator */
+    typedef MarkdownNodes::iterator MarkdownNodeIterator;
+}
+
+#endif

data/ext/drafter/ext/snowcrash/ext/markdown-parser/src/MarkdownParser.cc

@@ -0,0 +1,388 @@
+//
+//  MarkdownParser.cc
+//  markdownparser
+//
+//  Created by Zdenek Nemec on 4/18/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include <cstring>
+#include <stdexcept>
+#include "MarkdownParser.h"
+
+using namespace mdp;
+
+const size_t MarkdownParser::OutputUnitSize = 64;
+const size_t MarkdownParser::MaxNesting = 128;
+const int MarkdownParser::ParserExtensions = MKDEXT_FENCED_CODE | MKDEXT_NO_INTRA_EMPHASIS | MKDEXT_LAX_SPACING /*| MKDEXT_TABLES */;
+
+#define NO_WORKING_NODE_ERR std::logic_error("no working node")
+#define WORKING_NODE_MISMATCH_ERR std::logic_error("working node mismatch")
+
+/**
+ *  \brief  Create a byte buffer from a sundown buffer
+ */
+static ByteBuffer ByteBufferFromSundown(const struct buf *text)
+{
+    if (!text || !text->data || !text->size)
+        return ByteBuffer();
+    
+    return ByteBuffer(reinterpret_cast<char *>(text->data), text->size);
+}
+
+MarkdownParser::MarkdownParser()
+: m_workingNode(NULL), m_listBlockContext(false), m_source(NULL), m_sourceLength(0)
+{
+}
+
+void MarkdownParser::parse(const ByteBuffer& source, MarkdownNode& ast)
+{
+    ast = MarkdownNode();
+    m_workingNode = &ast;
+    m_workingNode->type = RootMarkdownNodeType;
+    m_workingNode->sourceMap.push_back(BytesRange(0, source.length()));
+    m_source = &source;
+    m_sourceLength = source.length();
+    m_listBlockContext = false;    
+    
+    RenderCallbacks callbacks = renderCallbacks();
+
+    ::sd_markdown *sundown = ::sd_markdown_new(ParserExtensions, MaxNesting, &callbacks, renderCallbackData());
+    ::buf *output = ::bufnew(OutputUnitSize);
+    
+    ::sd_markdown_render(output, reinterpret_cast<const uint8_t *>(source.c_str()), source.length(), sundown);
+    
+    ::bufrelease(output);
+    ::sd_markdown_free(sundown);
+    
+    m_workingNode = NULL;
+    m_source = NULL;
+    m_sourceLength = 0;
+    m_listBlockContext = false;
+    
+#ifdef DEBUG
+    ast.printNode();
+#endif
+}
+
+MarkdownParser::RenderCallbacks MarkdownParser::renderCallbacks()
+{
+    RenderCallbacks callbacks;
+    ::memset(&callbacks, 0, sizeof(RenderCallbacks));
+    
+    callbacks.blockcode = &MarkdownParser::renderBlockCode;
+    callbacks.blockquote = &MarkdownParser::renderQuote;
+    callbacks.blockhtml = &MarkdownParser::renderHTML;
+    callbacks.header = &MarkdownParser::renderHeader;
+    callbacks.hrule = &MarkdownParser::renderHorizontalRule;
+    callbacks.list = &MarkdownParser::renderList;
+    callbacks.listitem = &MarkdownParser::renderListItem;
+    callbacks.paragraph = &MarkdownParser::renderParagraph;
+    
+    callbacks.table = NULL;
+    callbacks.table_row = NULL;
+    callbacks.table_cell = NULL;
+    
+    callbacks.blockquote_begin = &MarkdownParser::beginQuote;
+    callbacks.list_begin = &MarkdownParser::beginList;
+    callbacks.listitem_begin = &MarkdownParser::beginListItem;
+    
+    callbacks.block_did_parse = &MarkdownParser::blockDidParse;
+    
+    return callbacks;
+}
+
+MarkdownParser::RenderCallbackData MarkdownParser::renderCallbackData()
+{
+    return this;
+}
+
+void MarkdownParser::renderHeader(struct buf *ob, const struct buf *text, int level, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderHeader(ByteBufferFromSundown(text), level);
+}
+
+void MarkdownParser::renderHeader(const ByteBuffer& text, int level)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(HeaderMarkdownNodeType, m_workingNode, text, level);
+    m_workingNode->children().push_back(node);
+}
+
+void MarkdownParser::beginList(int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginList(flags);
+}
+
+void MarkdownParser::beginList(int flags)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+}
+
+void MarkdownParser::renderList(struct buf *ob, const struct buf *text, int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderList(ByteBufferFromSundown(text), flags);
+}
+
+void MarkdownParser::renderList(const ByteBuffer& text, int flags)
+{
+    m_listBlockContext = true;
+}
+
+void MarkdownParser::beginListItem(int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginListItem(flags);
+}
+
+void MarkdownParser::beginListItem(int flags)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(ListItemMarkdownNodeType, m_workingNode, ByteBuffer(), flags);
+    m_workingNode->children().push_back(node);
+    
+    // Push context
+    m_workingNode = &m_workingNode->children().back();
+}
+
+void MarkdownParser::renderListItem(struct buf *ob, const struct buf *text, int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderListItem(ByteBufferFromSundown(text), flags);
+}
+
+void MarkdownParser::renderListItem(const ByteBuffer& text, int flags)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+
+    if (m_workingNode->type != ListItemMarkdownNodeType)
+        throw WORKING_NODE_MISMATCH_ERR;
+    
+    // No "inline" list items:
+    // Instead of storing the text on the list item
+    // create the artificial paragraph node to store the text.
+    if (m_workingNode->children().empty() ||
+        m_workingNode->children().front().type != ParagraphMarkdownNodeType) {
+        MarkdownNode textNode(ParagraphMarkdownNodeType, m_workingNode, text);
+        m_workingNode->children().push_front(textNode);
+    }
+    
+    m_workingNode->data = flags;
+    
+    // Pop context
+    m_workingNode = &m_workingNode->parent();
+}
+
+void MarkdownParser::renderBlockCode(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderBlockCode(ByteBufferFromSundown(text), ByteBufferFromSundown(lang));
+}
+
+void MarkdownParser::renderBlockCode(const ByteBuffer& text, const ByteBuffer& language)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(CodeMarkdownNodeType, m_workingNode, text);
+    m_workingNode->children().push_back(node);
+}
+
+void MarkdownParser::renderParagraph(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderParagraph(ByteBufferFromSundown(text));
+}
+
+void MarkdownParser::renderParagraph(const ByteBuffer& text)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(ParagraphMarkdownNodeType, m_workingNode, text);
+    m_workingNode->children().push_back(node);
+}
+
+void MarkdownParser::renderHorizontalRule(struct buf *ob, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderHorizontalRule();
+}
+
+void MarkdownParser::renderHorizontalRule()
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(HRuleMarkdownNodeType, m_workingNode, ByteBuffer(), MarkdownNode::Data());
+    m_workingNode->children().push_back(node);
+}
+
+void MarkdownParser::renderHTML(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderHTML(ByteBufferFromSundown(text));
+}
+
+void MarkdownParser::renderHTML(const ByteBuffer& text)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(HTMLMarkdownNodeType, m_workingNode, text);
+    m_workingNode->children().push_back(node);
+}
+
+void MarkdownParser::beginQuote(void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginQuote();
+}
+
+void MarkdownParser::beginQuote()
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    MarkdownNode node(QuoteMarkdownNodeType, m_workingNode);
+    m_workingNode->children().push_back(node);
+    
+    // Push context
+    m_workingNode = &m_workingNode->children().back();
+}
+
+void MarkdownParser::renderQuote(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderQuote(ByteBufferFromSundown(text));
+}
+
+void MarkdownParser::renderQuote(const ByteBuffer& text)
+{
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+    
+    if (m_workingNode->type != QuoteMarkdownNodeType)
+        throw WORKING_NODE_MISMATCH_ERR;
+    
+    m_workingNode->text = text;
+
+    // Pop context
+    m_workingNode = &m_workingNode->parent();
+}
+
+void MarkdownParser::blockDidParse(const src_map* map, const uint8_t *txt_data, size_t size, void *opaque)
+{
+    if (!opaque || !map)
+        return;
+    
+    BytesRangeSet sourceMap;
+    for (size_t i = 0; i < map->size; ++i) {
+        BytesRange byteRange(((range *)map->item[i])->loc, ((range *)map->item[i])->len);
+        sourceMap.push_back(byteRange);
+    }
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->blockDidParse(sourceMap);
+}
+
+void MarkdownParser::blockDidParse(const BytesRangeSet& sourceMap)
+{
+    if (m_listBlockContext) {
+        m_listBlockContext = false; // ignore list blocks events
+        return;
+    }
+    
+    if (!m_workingNode)
+        throw NO_WORKING_NODE_ERR;
+
+    if (m_workingNode->children().empty())
+        return;
+    
+    MarkdownNode &lMarkdownNode = m_workingNode->children().back();
+
+    // Sundown +1 newline compensation
+    //
+    // If new source map would exceed the actual source size
+    // this happens when sundown appends an artifical new line
+    // truncate the source map length to match the actual size
+    if (sourceMap.back().location + sourceMap.back().length > m_sourceLength) {
+        
+        size_t workMapLength = m_sourceLength - sourceMap.back().location;
+        if (!workMapLength)
+            return; // Ignore any artifical trailing new lines in source maps
+        
+        BytesRangeSet workMap = sourceMap;
+        workMap.back().length = workMapLength;
+        lMarkdownNode.sourceMap.append(workMap);
+    }
+    else {
+
+        lMarkdownNode.sourceMap.append(sourceMap);
+    }
+    
+    // No "inline" list items:
+    // Share the list item source map with its artifical node, if exists.
+    if (lMarkdownNode.type == ListItemMarkdownNodeType &&
+        !lMarkdownNode.children().empty() &&
+        lMarkdownNode.children().front().sourceMap.empty()) {
+        
+        ByteBuffer& buffer = lMarkdownNode.children().front().text;
+        ByteBuffer mapped = MapBytesRangeSet(sourceMap, *m_source);
+        size_t pos = mapped.find(buffer);
+
+        if (pos != mapped.npos) {
+            BytesRange range = sourceMap.front();
+            range.location += pos;
+            range.length = buffer.length();
+            BytesRangeSet newMap;
+            newMap.push_back(range);
+            lMarkdownNode.children().front().sourceMap.append(newMap);
+        }
+        else {
+            lMarkdownNode.children().front().sourceMap.append(sourceMap);
+        }
+    }
+}