redsnow 0.0.8

data/ext/snowcrash/src/CSourceAnnotation.h

@@ -0,0 +1,106 @@
+//
+//  CSourceAnnotation.h
+//  snowcrash
+//  C Implementation of SourceAnnotation.h for binding purposes
+//
+//  Created by Ali Khoramshahi on 13/6/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SC_C_SOURCEANNOTATION_H
+#define SC_C_SOURCEANNOTATION_H
+
+#include "Platform.h"
+#include "stdlib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /** Class Result wrapper */
+    struct sc_result_s;
+    typedef struct sc_result_s sc_result_t;
+
+    /** Array warnings wrapper */
+    struct sc_warnings_s;
+    typedef struct sc_warnings_s sc_warnings_t;
+
+    /** Class warning wrapper */
+    struct sc_warning_s;
+    typedef struct sc_warning_s sc_warning_t;
+
+    /** Class error wrapper */
+    struct sc_error_s;
+    typedef struct sc_error_s sc_error_t;
+
+    /** Class location wrapper */
+    struct sc_location_s;
+    typedef struct sc_location_s sc_location_t;
+
+    /** Class SourceAnnotation wrapper */
+    struct sc_source_annotation_s;
+    typedef struct sc_source_annotation_s sc_source_annotation_t;
+
+    /*----------------------------------------------------------------------*/
+
+    /** \returns pointer to allocated Result*/
+    SC_API sc_result_t* sc_result_new();
+
+    /** \deallocate Result from pointer*/
+    SC_API void sc_result_free(sc_result_t* result);
+
+    /*----------------------------------------------------------------------*/
+
+    /** \returns location handler*/
+    SC_API const sc_location_t* sc_location_handler(const sc_source_annotation_t* source);
+
+    /** \returns location array size*/
+    SC_API size_t sc_location_size(const sc_location_t* location);
+
+    /** \returns location at `index` length*/
+    SC_API size_t sc_location_length(const sc_location_t* location, size_t index);
+
+    /** \returns location at `index` location*/
+    SC_API size_t sc_location_location(const sc_location_t* location, size_t index);
+
+    /*----------------------------------------------------------------------*/
+
+    /** \returns error handler*/
+    SC_API const sc_error_t* sc_error_handler(const sc_result_t* result);
+
+    /** \returns error message*/
+    SC_API const char* sc_error_message(const sc_error_t* error);
+
+    /** \returns error code*/
+    SC_API int sc_error_code(const sc_error_t* error);
+
+    /** \returns error OK*/
+    SC_API int sc_error_ok(const sc_error_t* error);
+
+    /*----------------------------------------------------------------------*/
+
+    /** \returns warnings handler*/
+    SC_API const sc_warnings_t* sc_warnings_handler(const sc_result_t* result);
+
+    /** \returns warnings array size*/
+    SC_API size_t sc_warnings_size(const sc_warnings_t* warning);
+
+    /*----------------------------------------------------------------------*/
+
+    /** \returns warning at `index` handle*/
+    SC_API const sc_warning_t* sc_warning_handler(const sc_warnings_t* warning, size_t index);
+
+    /** \returns warning message*/
+    SC_API const char* sc_warning_message(const sc_warning_t* warning);
+
+    /** \returns warning code*/
+    SC_API int sc_warning_code(const sc_warning_t* warning);
+
+    /** \returns warning OK*/
+    SC_API int sc_warning_ok(const sc_warning_t* warning);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/snowcrash/src/CodeBlockUtility.h

@@ -0,0 +1,189 @@
+//
+//  CodeBlockUtility.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 11/10/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_CODEBLOCKUTILITY_H
+#define SNOWCRASH_CODEBLOCKUTILITY_H
+
+#include <sstream>
+#include "BlockUtility.h"
+
+namespace snowcrash {
+    
+    /**
+     *  Compute expected indentation level of a code block.
+     *  \param  section A section to compute indentation level for
+     *  \return Indentation level (number of tabs) for a block to be
+     *  considered a pre-formatted code block in given section.
+     */
+    FORCEINLINE size_t CodeBlockIndentationLevel(const BlueprintSection& section)
+    {
+        if (!section.hasParent() ||
+            section.parent().type == BlueprintSectionType ||
+            section.parent().type == ResourceGroupSectionType ||
+            section.parent().type == ResourceSectionType ||
+            section.parent().type == ResourceMethodSectionType ||
+            section.parent().type == ActionSectionType) {
+            
+            return 1;
+        }
+        else if (section.parent().type == RequestBodySectionType ||
+                 section.parent().type == ResponseBodySectionType ||
+                 section.parent().type == ObjectBodySectionType ||
+                 section.parent().type == ModelBodySectionType) {
+            
+            return 2;
+        }
+        else {
+            
+            return 3;
+        }
+    }
+    
+    /**
+     *  \brief Check code block for potential excessive indentation of a list item.
+     *  \return True if code block does not contain potential recognized list, false otherwise.
+     */
+    template <class T>
+    FORCEINLINE bool CheckCodeBlockListItem(const BlueprintSection& section,
+                                            const BlockIterator& cur,
+                                            const SourceData& sourceData,
+                                            Result& result)
+    {
+        
+        // Check for possible superfluous indentation of a recognized list items.
+        std::string line = GetFirstLine(cur->content);
+        TrimStringStart(line);
+        
+        // If line appears to be a Markdown list construct a dummy list item
+        // with the first line of code block as its content.
+        // Check the list item with respective internal classifier.
+        if (line.empty() ||
+            (line[0] != '-' && line[0] != '+' && line[0] != '*'))
+            return true;
+        
+        // Skip leading Markdown list item mark
+        std::string listItemContent = line.substr(1, std::string::npos);
+        TrimStringStart(listItemContent);
+        MarkdownBlock::Stack dummyList;
+        
+        dummyList.push_back(MarkdownBlock(ListItemBlockBeginType, SourceData(), 0, SourceDataBlock()));
+        dummyList.push_back(MarkdownBlock(ListItemBlockEndType, listItemContent, 0, MakeSourceDataBlock(0, 0)));
+        
+        SectionType type = ClassifyInternaListBlock<T>(dummyList.begin(), dummyList.end());
+        if (type != UndefinedSectionType) {
+            
+            size_t level = CodeBlockIndentationLevel(section);
+            --level;
+            
+            // WARN: Superfluous indentation
+            std::stringstream ss;
+            ss << "excessive indentation, ";
+            ss << SectionName(type) << " ";
+            if (level) {
+                ss << "section is expected to be indented by just ";
+                ss << level * 4 << " spaces or " << level << " tab";
+                if (level > 1)
+                    ss << "s";
+            }
+            else {
+                ss << "section is not expected to be indented";
+            }
+            
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur,
+                                                                     cur,
+                                                                     section.bounds,
+                                                                     sourceData);
+            result.warnings.push_back(Warning(ss.str(),
+                                              IndentationWarning,
+                                              sourceBlock));
+            
+            return false;
+        }
+        
+        return true;
+    }
+    
+    /**
+     *  \brief  Parses given block as a preformatted code block.
+     *  \param  section     Actual section being parsed.
+     *  \param  cur         Cursor within the section boundaries.
+     *  \param  parser      Parser instance.
+     *  \param  action      An output data buffer.
+     *  \param  sourceMap   An output source map buffer.
+     *  \return A block parser section result, pointing at the last block parsed.
+     */
+    template <class T>
+    FORCEINLINE ParseSectionResult ParsePreformattedBlock(const BlueprintSection& section,
+                                                          const BlockIterator& cur,
+                                                          BlueprintParserCore& parser,
+                                                          SourceData& data,
+                                                          SourceDataBlock& sourceMap) {
+        
+        ParseSectionResult result = std::make_pair(Result(), cur);
+        BlockIterator sectionCur = cur;
+        std::stringstream dataStream;
+        
+        if (sectionCur->type == CodeBlockType) {
+            // Well formatted content, stream it up
+            dataStream << sectionCur->content;
+            
+            // Check for excessive indentation
+            CheckCodeBlockListItem<T>(section, sectionCur, parser.sourceData, result.first);
+        }
+        else {
+            // Other blocks, process & warn
+            if (sectionCur->type == QuoteBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, QuoteBlockBeginType, QuoteBlockEndType);
+            }
+            else if (sectionCur->type == ListBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListBlockBeginType, ListBlockEndType);
+            }
+            else if (sectionCur->type == ListItemBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListItemBlockBeginType, ListItemBlockEndType);
+            }
+            
+            if (!CheckCursor(section, sectionCur, parser.sourceData, result.first))
+                return result;
+            dataStream << MapSourceData(parser.sourceData, sectionCur->sourceMap);
+            
+            // WARN: Not a preformatted code block
+            std::stringstream ss;
+            
+            // Build the warning message
+            size_t level = CodeBlockIndentationLevel(section);
+            if (section.type == DanglingBodySectionType ||
+                section.type == DanglingSchemaSectionType) {
+                
+                ss << "dangling " << SectionName(section.type) << " asset, ";
+                ss << "expected a pre-formatted code block, indent every of its line by ";
+                ss << level * 4 << " spaces or " << level << " tabs";
+            }
+            else {
+                
+                ss << SectionName(section.type) << " asset ";
+                ss << "is expected to be a pre-formatted code block, every of its line indented by exactly ";
+                ss << level * 4 << " spaces or " << level << " tabs";
+            }
+            
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, parser.sourceData);
+            result.first.warnings.push_back(Warning(ss.str(),
+                                                    IndentationWarning,
+                                                    sourceBlock));
+        }
+        
+        data = dataStream.str();
+        sourceMap = sectionCur->sourceMap;
+        
+        if (sectionCur != section.bounds.second)
+            result.second = ++sectionCur;
+        
+        return result;
+    }
+}
+
+#endif

data/ext/snowcrash/src/DescriptionSectionUtility.h

@@ -0,0 +1,156 @@
+//
+//  DescriptionSectionUtility.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 11/10/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_DESCRIPTIONSECTIONUTILITY_H
+#define SNOWCRASH_DESCRIPTIONSECTIONUTILITY_H
+
+#include <sstream>
+#include "MarkdownBlock.h"
+#include "BlueprintParserCore.h"
+#include "CodeBlockUtility.h"
+
+namespace snowcrash {
+    
+    
+    /**
+     *  \brief  Skips to the end of the description list.
+     *  \param  begin   Begin of the description list.
+     *  \param  end     End of the block buffer.
+     *  \param  descriptionMap  Output buffer containing skipped source map.
+     *  \return An iterator pointing to the last block of a description list.
+     *          Or, if one of description list items is recognized as a section, iterator
+     *          pointing to this section.
+     *
+     *  This functions checks any skipped list items for a section signature.
+     *  If a section signature is found this function returns the first block
+     *  of the recognized section. If no signature is found this function returns
+     *  the last (closing) block of the description list.
+     */
+    template <class T>
+    static BlockIterator SkipToDescriptionListEnd(const BlockIterator& begin,
+                                                  const BlockIterator& end,
+                                                  SourceDataBlock& descriptionMap) {
+        BlockIterator cur(begin);
+        if (++cur == end)   // Skip leading ListBlockBeginType
+            return cur;
+        
+        std::vector<SourceDataBlock> listItemMaps;
+        SectionType listItemSection = UndefinedSectionType;
+        BlockIterator recognizedCur = end;
+        
+        while (cur != end &&
+               cur->type == ListItemBlockBeginType) {
+            
+            // Classify list item
+            listItemSection = ClassifyInternaListBlock<T>(cur, end);
+            if (listItemSection != UndefinedSectionType) {
+                // Found a recognized section, record & skip to the end of the list.
+                recognizedCur = cur;
+                cur = SkipToClosingBlock(begin, end, ListBlockBeginType, ListBlockEndType);
+            }
+            else {
+                // Skip one list item & take note of its source map
+                cur = SkipToClosingBlock(cur, end, ListItemBlockBeginType, ListItemBlockEndType);
+                listItemMaps.push_back(cur->sourceMap);
+                
+                if (cur != end)
+                    ++cur;
+            }
+        }
+        
+        // Resolve
+        if (listItemSection == UndefinedSectionType) {
+            descriptionMap = cur->sourceMap;
+            return cur;
+        }
+        else {
+            // Resolve correct description source map
+            descriptionMap.clear();
+            if (!cur->sourceMap.empty() &&
+                !listItemMaps.empty() &&
+                !listItemMaps.front().empty()) {
+                
+                SourceDataRange r;
+                r.location = cur->sourceMap.front().location;
+                r.length = listItemMaps.front().front().location - r.location;
+                descriptionMap.push_back(r);
+                
+                for (std::vector<SourceDataBlock>::iterator it = listItemMaps.begin();
+                     it != listItemMaps.end();
+                     ++it) {
+                    
+                    SourceDataRange gap;
+                    gap.location = descriptionMap.back().location + descriptionMap.back().length;
+                    gap.length = it->front().location - gap.location;
+                    if (gap.length) {
+                        SourceDataBlock gapBlock(1, gap);
+                        AppendSourceDataBlock(descriptionMap, gapBlock);
+                    }
+                    
+                    AppendSourceDataBlock(descriptionMap, *it);
+                }
+            }
+            
+            return recognizedCur;
+        }
+    }
+    
+    /**
+     *  \brief  Process a description block retrieving its content.
+     *  \param  section     A section its block is being processed.
+     *  \param  cur         Cursor to the block to process.
+     *  \param  sourceData  Source data stream.
+     *  \param  output      Output object to APPEND retrieved description into.
+     *  \return Standard parser section result poinitng at the last block parsed.
+     */
+    template <class T>
+    FORCEINLINE ParseSectionResult ParseDescriptionBlock(const BlueprintSection& section,
+                                                         const BlockIterator& cur,
+                                                         const SourceData& sourceData,
+                                                         T& output) {
+        
+        ParseSectionResult result = std::make_pair(Result(), cur);
+        BlockIterator sectionCur(cur);
+        
+        if (sectionCur->type == QuoteBlockBeginType) {
+            sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, QuoteBlockBeginType, QuoteBlockEndType);
+        }
+        else if (sectionCur->type == ListBlockBeginType) {
+            
+            SourceDataBlock descriptionMap;
+            sectionCur = SkipToDescriptionListEnd<T>(sectionCur, section.bounds.second, descriptionMap);
+
+            if (sectionCur->type != ListBlockEndType) {
+                // Found recognized lists in the list block
+                if (!descriptionMap.empty())
+                    output.description += MapSourceData(sourceData, descriptionMap);
+                
+                result.second = sectionCur;
+                return result;
+            }
+        }
+        else if (sectionCur->type == CodeBlockType) {
+            // Check code block for potential excessive indentation of a list item
+            CheckCodeBlockListItem<T>(section, sectionCur, sourceData, result.first);
+        }
+        else if (sectionCur->type == HeaderBlockType) {
+            // Check headers for potential keywords
+            CheckHeaderBlock<T>(section, sectionCur, sourceData, result.first);
+        }
+        
+        if (!CheckCursor(section, sectionCur, sourceData, result.first))
+            return result;
+
+        output.description += MapSourceData(sourceData, sectionCur->sourceMap);
+        result.second = ++sectionCur;
+        
+        return result;
+    }
+}
+
+#endif