redsnow 0.0.8

data/ext/snowcrash/src/ListUtility.h

@@ -0,0 +1,95 @@
+//
+//  ListUtility.h
+//  snowcrash
+//
+//  Deprecation Warning:    The content of this file should be
+//                          eventually replaced by the ListBlockUtility.h.
+//
+//  Created by Zdenek Nemec on 5/12/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_LISTUTILITY_H
+#define SNOWCRASH_LISTUTILITY_H
+
+#include <vector>
+#include <string>
+#include <sstream>
+#include "MarkdownBlock.h"
+#include "BlueprintParserCore.h"
+#include "CodeBlockUtility.h"
+
+namespace snowcrash {
+    
+    // Pair of content parts
+    typedef std::vector<MarkdownBlock::Content> ContentParts;
+        
+    // Extract first line from block content
+    // ContentParts[0] contains first line of block content
+    // ContentParts[1] contains the rest of block content
+    FORCEINLINE ContentParts ExtractFirstLine(const MarkdownBlock& block) {
+        
+        ContentParts result;
+        if (block.content.empty())
+            return result;
+        
+        std::string::size_type pos = block.content.find("\n");
+        if (pos == std::string::npos) {
+            result.push_back(block.content);
+            return result;
+        }
+        
+        result.push_back(block.content.substr(0, pos + 1));
+        result.push_back(block.content.substr(pos + 1, std::string::npos));
+        return result;
+    }
+    
+    // Return first list / list item content block block (paragraph)
+    // This is the first block inside the list / list item or the list item's closing block
+    // DEPRECATED - use ContentBlock() or SkipSignatureBlock() instead
+    FORCEINLINE BlockIterator FirstContentBlock(const BlockIterator& begin,
+                                                const BlockIterator& end) {
+        
+        BlockIterator cur = begin;
+        if (cur->type == ListBlockBeginType)
+            if (++cur == end)
+                return end;
+        
+        if (cur->type == ListItemBlockBeginType)
+            if (++cur == end)
+                return end;
+        
+        return cur;
+    }
+
+    
+    // Returns true if list item (begin) contains nested list block false otherwise
+    // Look ahead. 
+    FORCEINLINE bool HasNestedListBlock(const BlockIterator& begin,
+                                        const BlockIterator& end) {
+
+        BlockIterator sectionBegin = begin;
+        if (sectionBegin == end)
+            return false;
+        
+        if (sectionBegin->type == ListBlockBeginType &&
+            ++sectionBegin == end)
+            return false;
+
+        if (sectionBegin->type != ListItemBlockBeginType)
+            return false;
+        
+        BlockIterator sectionEnd = SkipToClosingBlock(sectionBegin,
+                                                    end,
+                                                    ListItemBlockBeginType,
+                                                    ListItemBlockEndType);
+        for (BlockIterator it = sectionBegin; it != sectionEnd; ++it) {
+            if (it->type == ListBlockBeginType)
+                return true;
+        }
+        
+        return false;
+    }
+}
+
+#endif

data/ext/snowcrash/src/MarkdownBlock.cc

@@ -0,0 +1,176 @@
+//
+//  MarkdownBlock.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/15/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <sstream>
+#include "MarkdownBlock.h"
+
+#ifdef DEBUG
+#include <iostream>
+#endif
+
+std::string snowcrash::BlockName(const MarkdownBlockType& blockType)
+{
+    switch (blockType) {
+        case UndefinedBlockType:
+            return "undefined";
+            
+        case CodeBlockType:
+            return "code";
+            
+        case QuoteBlockBeginType:
+        case QuoteBlockEndType:
+            return "quote";
+            
+        case HTMLBlockType:
+            return "html";
+            
+        case HeaderBlockType:
+            return "header";
+            
+        case ListBlockBeginType:
+        case ListBlockEndType:
+            return "list";
+            
+        case ListItemBlockBeginType:
+        case ListItemBlockEndType:
+            return "list item";
+            
+        case ParagraphBlockType:
+            return "paragraph";
+            
+        case TableBlockType:
+            return "table";
+            
+        case TableRowBlockType:
+            return "table row";
+            
+        case TableCellBlockType:
+            return "table cell";
+            
+        default:
+            return "markdown";
+    }
+}
+
+std::string snowcrash::MapSourceData(const SourceData& source, const SourceDataBlock& sourceMap)
+{
+    if (source.empty())
+        return std::string();
+    
+    size_t length = source.length();
+    std::stringstream ss;
+    for (SourceDataBlock::const_iterator it = sourceMap.begin(); it != sourceMap.end(); ++it) {
+        
+        if (it->location + it->length > length) {
+            // Sundown adds an extra newline on the source input if needed.
+            if (it->location + it->length - length) {
+                ss << source.substr(it->location, length - it->location);
+                return ss.str();
+            }
+            else {
+                // Wrong map
+                return std::string();
+            }
+        }
+        
+        ss << source.substr(it->location, it->length);
+    }
+    
+    return ss.str();
+}
+
+#ifdef DEBUG
+
+#include "Serialize.h"
+
+using namespace snowcrash;
+
+static std::string BlockTypeToString(MarkdownBlockType type) {
+    switch (type) {
+        case UndefinedBlockType:
+            return "UndefinedBlockType";
+            
+        case CodeBlockType:
+            return "CodeBlockType";
+            
+        case QuoteBlockBeginType:
+            return "QuoteBlockBeginType";
+            
+        case QuoteBlockEndType:
+            return "QuoteBlockEndType";
+            
+        case HTMLBlockType:
+            return "HTMLBlockType";
+            
+        case HeaderBlockType:
+            return "HeaderBlockType";
+            
+        case HRuleBlockType:
+            return "HRuleBlockType";
+            
+        case ListBlockBeginType:
+            return "ListBlockBeginType";
+            
+        case ListBlockEndType:
+            return "ListBlockEndType";
+            
+        case ListItemBlockBeginType:
+            return "ListItemBlockBeginType";
+            
+        case ListItemBlockEndType:
+            return "ListItemBlockEndType";
+            
+        case ParagraphBlockType:
+            return "ParagraphBlockType";
+            
+        case TableBlockType:
+            return "TableBlockType";
+            
+        case TableRowBlockType:
+            return "TableRowBlockType";
+            
+        case TableCellBlockType:
+            return "TableCellBlockType";
+            
+        default:
+            return "n/a";
+    }
+}
+
+void snowcrash::printMarkdown(const MarkdownBlock::Stack& markdown, unsigned int level)
+{
+    std::string indent;
+    for (unsigned int i = 0; i < level; ++i) {
+        indent += "  ";
+    }
+
+    for (MarkdownBlock::Stack::const_iterator block = markdown.begin(); block != markdown.end(); ++block) {
+    
+        std::cout << indent << BlockTypeToString(block->type);
+        if (block->content.length()) {
+            std::cout << ", content: '" << EscapeNewlines(block->content) << "'";
+        }
+        
+        if (!block->sourceMap.empty()) {
+            for (SourceDataBlock::const_iterator sourceMap = block->sourceMap.begin();
+                 sourceMap != block->sourceMap.end();
+                 ++sourceMap) {
+                
+                std::cout << ((sourceMap == block->sourceMap.begin()) ? ", :" : ";");
+                std::cout << sourceMap->location << ":" << sourceMap->length;
+            }
+        }
+        
+        std::cout << std::endl;
+    }
+    
+    if (level == 0)
+        std::cout << std::endl;    
+}
+
+#endif

data/ext/snowcrash/src/MarkdownBlock.h

@@ -0,0 +1,93 @@
+//
+//  MarkdownBlock.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/15/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MARKDOWBLOCK_H
+#define SNOWCRASH_MARKDOWBLOCK_H
+
+#include <vector>
+#include <string>
+#include "ParserCore.h"
+
+namespace snowcrash {
+    
+    /** Type of a Markdown Block */
+    enum MarkdownBlockType {
+        UndefinedBlockType = 0,
+        CodeBlockType = 1,
+        QuoteBlockBeginType = 2,
+        QuoteBlockEndType = 3,
+        HTMLBlockType = 4,
+        HeaderBlockType = 5,
+        HRuleBlockType = 6,
+        ListBlockBeginType = 7,
+        ListBlockEndType = 8,
+        ListItemBlockBeginType = 9,
+        ListItemBlockEndType = 10,
+        ParagraphBlockType = 11,
+        TableBlockType = 12,
+        TableRowBlockType = 13,
+        TableCellBlockType = 14
+    };
+    
+    /**
+     *  \return Name of the markdown block.
+     */
+    std::string BlockName(const MarkdownBlockType& blockType);
+
+    /**
+     *  Markdown Block Element
+     */
+    struct MarkdownBlock {
+
+        typedef std::vector<MarkdownBlock> Stack;
+        typedef SourceData Content;
+        typedef int Data;
+
+        MarkdownBlock()
+        : type(UndefinedBlockType), data(0) {}
+        
+        MarkdownBlock(MarkdownBlockType t, Content c = Content(), Data d = Data(), SourceDataBlock map = SourceDataBlock())
+        { type = t; content = c; data = d; sourceMap = map; }
+        
+        MarkdownBlock(const MarkdownBlock& b)
+        { type = b.type; content = b.content; data = b.data; sourceMap = b.sourceMap; }
+        
+        virtual ~MarkdownBlock() {}
+        
+        MarkdownBlock& operator=(const MarkdownBlock& b)
+        { type = b.type; content = b.content; data = b.data; sourceMap = b.sourceMap; return *this; }
+        
+        // Type of the Markdown Block
+        MarkdownBlockType type;
+        
+        // Text content excluding nested blocks
+        Content content;
+        
+        // Arbitrary data from parser
+        Data data;
+        
+        // Position of this block in source module
+        SourceDataBlock sourceMap;
+    };
+
+    /**
+     *  \brief  Maps block of source data bytes into source string.
+     *  \param  block   A %SourceDataBlock to map into %SourceCharactersBlock
+     *  \param  data    A mapped source data.
+     *  \returns A string concatenated from the source string using the byte map.
+     */
+    std::string MapSourceData(const SourceData& source, const SourceDataBlock& sourceMap);
+        
+#ifdef DEBUG
+    // Prints markdown block recursively to stdout
+    void printMarkdown(const MarkdownBlock::Stack& markdown, unsigned int level = 0);
+#endif
+
+}
+
+#endif

data/ext/snowcrash/src/MarkdownParser.cc

@@ -0,0 +1,266 @@
+//
+//  MarkdownParser.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/15/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <cstring>
+#include "MarkdownParser.h"
+
+using namespace snowcrash;
+
+// Returns text from sundown buffer
+static std::string BufText(const struct buf *text)
+{
+    if (!text || !text->data || !text->size)
+        return std::string();
+    
+    return std::string(reinterpret_cast<char *>(text->data), text->size);
+}
+
+const size_t MarkdownParser::OutputUnitSize = 64;
+const size_t MarkdownParser::MaxNesting = 16;
+const int MarkdownParser::ParserExtensions = MKDEXT_FENCED_CODE | MKDEXT_NO_INTRA_EMPHASIS | MKDEXT_LAX_SPACING /*| MKDEXT_TABLES */;
+
+void MarkdownParser::parse(const SourceData& source, Result& result, MarkdownBlock::Stack& markdown)
+{
+    // Push default render stack
+    m_renderStack.clear();
+    
+    // Build render callbacks & setup parser
+    RenderCallbacks callbacks = renderCallbacks();
+	sd_markdown *sundown = sd_markdown_new(ParserExtensions, MaxNesting, &callbacks, renderCallbackData());
+    
+    buf *output = bufnew(OutputUnitSize);
+
+    // Parse & build AST
+    sd_markdown_render(output, reinterpret_cast<const uint8_t *>(source.c_str()), source.length(), sundown);
+
+    bufrelease(output);
+    sd_markdown_free(sundown);
+
+    // Compose final Markdown object
+    markdown = m_renderStack; // FIXME: C++11 move
+
+#ifdef DEBUG
+    printMarkdown(markdown, 0);
+#endif
+
+}
+
+MarkdownParser::RenderCallbacks MarkdownParser::renderCallbacks()
+{
+    // Custom callbacks
+    sd_callbacks callbacks;
+    ::memset(&callbacks, 0, sizeof(sd_callbacks));
+
+    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;
+    
+    // FUTURE: Table support
+    callbacks.table = NULL;
+    callbacks.table_row = NULL;
+    callbacks.table_cell = NULL;
+    
+    // AST building extensions
+    callbacks.blockquote_begin = &MarkdownParser::beginQuote;
+    callbacks.list_begin = &MarkdownParser::beginList;
+    callbacks.listitem_begin = &MarkdownParser::beginListItem;
+    
+    // Source maps
+    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(BufText(text), level);
+}
+
+void MarkdownParser::renderHeader(const std::string& text, int level)
+{
+    m_renderStack.push_back(MarkdownBlock(HeaderBlockType, text, level));
+}
+
+void MarkdownParser::beginList(int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginList(flags);
+}
+
+void MarkdownParser::beginList(int flags)
+{
+    m_renderStack.push_back(MarkdownBlock(ListBlockBeginType, SourceData(), flags));
+}
+
+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(BufText(text), flags);
+}
+
+void MarkdownParser::renderList(const std::string& text, int flags)
+{
+    m_renderStack.push_back(MarkdownBlock(ListBlockEndType, text, flags));
+}
+
+void MarkdownParser::beginListItem(int flags, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginListItem(flags);
+}
+
+void MarkdownParser::beginListItem(int flags)
+{
+    m_renderStack.push_back(MarkdownBlock(ListItemBlockBeginType, SourceData(), flags));
+}
+
+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(BufText(text), flags);
+}
+
+void MarkdownParser::renderListItem(const std::string& text, int flags)
+{
+    m_renderStack.push_back(MarkdownBlock(ListItemBlockEndType, text, flags));
+}
+
+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(BufText(text), BufText(lang));
+}
+
+void MarkdownParser::renderBlockCode(const std::string& text, const std::string& language)
+{
+    m_renderStack.push_back(MarkdownBlock(CodeBlockType, text));
+}
+
+void MarkdownParser::renderParagraph(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderParagraph(BufText(text));
+}
+
+void MarkdownParser::renderParagraph(const std::string& text)
+{
+    m_renderStack.push_back(MarkdownBlock(ParagraphBlockType, text));
+}
+
+void MarkdownParser::renderHorizontalRule(struct buf *ob, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderHorizontalRule();
+}
+
+void MarkdownParser::renderHorizontalRule()
+{
+    m_renderStack.push_back(MarkdownBlock(HRuleBlockType));
+}
+
+void MarkdownParser::renderHTML(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderHTML(BufText(text));
+}
+
+void MarkdownParser::renderHTML(const std::string& text)
+{
+    m_renderStack.push_back(MarkdownBlock(HTMLBlockType, text));
+}
+
+void MarkdownParser::beginQuote(void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->beginQuote();
+}
+
+void MarkdownParser::beginQuote()
+{
+    m_renderStack.push_back(MarkdownBlock(QuoteBlockBeginType, SourceData(), 0));
+}
+
+void MarkdownParser::renderQuote(struct buf *ob, const struct buf *text, void *opaque)
+{
+    if (!opaque)
+        return;
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->renderQuote(BufText(text));
+}
+
+void MarkdownParser::renderQuote(const std::string& text)
+{
+    m_renderStack.push_back(MarkdownBlock(QuoteBlockEndType, text, 0));
+}
+
+void MarkdownParser::blockDidParse(const src_map* map, const uint8_t *txt_data, size_t size, void *opaque)
+{
+    if (!opaque || !map)
+        return;
+    
+    SourceDataBlock sourceMap;
+    for (size_t i = 0; i < map->size; ++i) {
+        SourceDataRange sourceRange = {((range *)map->item[i])->loc, ((range *)map->item[i])->len};
+        sourceMap.push_back(sourceRange);
+    }
+    
+    MarkdownParser *p = static_cast<MarkdownParser *>(opaque);
+    p->blockDidParse(sourceMap);
+}
+
+void MarkdownParser::blockDidParse(const SourceDataBlock& sourceMap)
+{
+    if (m_renderStack.empty()) {
+        return;
+    }
+    
+    MarkdownBlock& lastBlock = m_renderStack.back();
+    AppendSourceDataBlock(lastBlock.sourceMap, sourceMap);
+}