redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/ListUtility.h

@@ -1,95 +0,0 @@
-//
-//  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

@@ -1,176 +0,0 @@
-//
-//  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

@@ -1,93 +0,0 @@
-//
-//  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

@@ -1,266 +0,0 @@
-//
-//  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);
-}