redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/BlueprintParserCore.h

@@ -1,190 +0,0 @@
-//
-//  BlueprintParserCore.h
-//  snowcrash
-//
-//  Created by Zdenek Nemec on 5/4/13.
-//  Copyright (c) 2013 Apiary Inc. All rights reserved.
-//
-
-#ifndef SNOWCRASH_BLUEPRINTPARSERCORE_H
-#define SNOWCRASH_BLUEPRINTPARSERCORE_H
-
-#include <algorithm>
-#include <sstream>
-#include "ParserCore.h"
-#include "SourceAnnotation.h"
-#include "MarkdownBlock.h"
-#include "BlueprintSection.h"
-#include "HTTP.h"
-#include "Blueprint.h"
-#include "BlueprintUtility.h"
-#include "StringUtility.h"
-#include "SymbolTable.h"
-
-namespace snowcrash {
-    
-    /**
-     *  \brief Blueprint Parser Options.
-     *
-     *  Controls blueprint parser behavior.
-     */
-    enum BlueprintParserOption {
-        RenderDescriptionsOption = (1 << 0),    /// < Render Markdown in description.
-        RequireBlueprintNameOption = (1 << 1)   /// < Treat missing blueprint name as error
-    };
-    
-    typedef unsigned int BlueprintParserOptions;
-    
-    /**
-     *  \brief Parsing subroutine result
-     *
-     *  Consists of a parsing result report (first) and
-     *  %BlockIterator (second) pointing to the last parsed
-     *  markdown block.
-     */
-    typedef std::pair<Result, BlockIterator> ParseSectionResult;
-    
-    
-    /**
-     *  Parser Core Data
-     */
-    struct BlueprintParserCore {
-        BlueprintParserCore(BlueprintParserOptions opts,
-                            const SourceData& src,
-                            const Blueprint& bp)
-        : options(opts), sourceData(src), blueprint(bp) {}
-        
-        /** Parser Options */
-        BlueprintParserOptions options;
-        
-        /** Symbol Table */
-        SymbolTable symbolTable;
-        
-        /** Source Data */
-        const SourceData& sourceData;
-        
-        /** AST being parsed **/
-        const Blueprint& blueprint;
-        
-    private:
-        BlueprintParserCore();
-        BlueprintParserCore(const BlueprintParserCore&);
-        BlueprintParserCore& operator=(const BlueprintParserCore&);
-    };
-    
-    /**
-     *  SectionType Parser prototype.
-     */
-    template<class T>
-    struct SectionParser {
-        
-        /**
-         *  \brief  Parse section's blocks.
-         *  \param  section     Actual section being parsed.
-         *  \param  cur         Cursor within the section boundaries.
-         *  \param  parser      Parser instance.
-         *  \param  output      AST node parsed.
-         *  \return %ParseSectionResult pointing to the last block parsed & including 
-         *  any possible source annotations in the form of results or warnings.
-         */
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               T& output);
-        
-        /**
-         *  \brief  Optional post-parse processing.
-         */
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             T& output,
-                             Result& result);
-    };
-    
-    /**
-     *  \brief Internal list items classifier prototype.
-     *
-     *  The classifier might look ahead.
-     *  DO NOT provide generic implementation.
-     */
-    template <class T>
-    FORCEINLINE SectionType ClassifyInternaListBlock(const BlockIterator& begin,
-                                                     const BlockIterator& end);
-    /**
-     *  \brief Classify a block with children list items.
-     *
-     *  Classifies internal list block & descend to children list block classifiers.
-     *  DO NOT provide generic implementation.
-     */
-    template <class T>
-    FORCEINLINE SectionType ClassifyChildrenListBlock(const BlockIterator& begin,
-                                                      const BlockIterator& end);
-        
-    /**
-     *  \brief Block Classifier prototype.
-     *
-     *  The classifier might look ahead.
-     */
-    template <class T>
-    FORCEINLINE SectionType ClassifyBlock(const BlockIterator& begin,
-                                          const BlockIterator& end,
-                                          const SectionType& context);
-    
-    // Forward declaration of classifier helpers
-    extern bool HasResourceGroupSignature(const MarkdownBlock& block);
-    extern bool HasActionSignature(const MarkdownBlock& block);
-    extern bool HasResourceSignature(const MarkdownBlock& block);
-    extern bool HasPayloadSignature(const BlockIterator& begin, const BlockIterator& end);
-    extern bool HasPayloadAssetSignature(const BlockIterator& begin, const BlockIterator& end);
-    extern bool HasAssetSignature(const BlockIterator& begin, const BlockIterator& end);
-    extern bool HasHeaderSignature(const BlockIterator& begin, const BlockIterator& end);
-    extern bool HasParametersSignature(const BlockIterator& begin, const BlockIterator& end);
-    
-    /**
-     *  \brief A Markdown block parser.
-     *
-     *  Iterates over blocks classifying sections and calling relevant %SectionParser P<T>.
-     */
-    template <class T, class P>
-    struct BlockParser : public P {
-        
-        // Iterate blocks, classify & parse
-        static ParseSectionResult Parse(const BlockIterator& begin,
-                                        const BlockIterator& end,
-                                        const BlueprintSection& parentSection,
-                                        BlueprintParserCore& parser,
-                                        T& output) {
-            Result result;
-            SectionType currentSectionType = UndefinedSectionType;
-            BlockIterator currentBlock = begin;
-            while (currentBlock != end) {
-                
-                currentSectionType = ClassifyBlock<T>(currentBlock, end, currentSectionType);
-                BlueprintSection currentSection(currentSectionType, std::make_pair(begin, end), parentSection);
-                
-                ParseSectionResult sectionResult = P::ParseSection(currentSection,
-                                                                   currentBlock,
-                                                                   parser,
-                                                                   output);
-                
-                result += sectionResult.first;
-                if (result.error.code != Error::OK)
-                    break;
-                
-                if (sectionResult.second == currentBlock)
-                    break;
-
-                currentBlock = sectionResult.second;
-
-                if (currentSectionType == UndefinedSectionType)
-                    break;
-            }
-            
-            P::Finalize(std::make_pair(begin, currentBlock), parser, output, result);
-            
-            return std::make_pair(result, currentBlock);
-        }        
-    };
-}
-
-#endif

data/ext/snowcrash/src/BlueprintSection.h

@@ -1,140 +0,0 @@
-//
-//  BlueprintSection.h
-//  snowcrash
-//
-//  Created by Zdenek Nemec on 11/1/13.
-//  Copyright (c) 2013 Apiary Inc. All rights reserved.
-//
-
-#ifndef SNOWCRASH_BLUEPRINTSECTION_H
-#define SNOWCRASH_BLUEPRINTSECTION_H
-
-#include "MarkdownBlock.h"
-#include "Blueprint.h"
-
-namespace snowcrash {
-    
-    /**
-     *  API Blueprint Sections Types. Block range classification.
-     */
-    enum SectionType {
-        UndefinedSectionType,           /// < Undefined section
-        BlueprintSectionType,           /// < Blueprint overview
-        ResourceGroupSectionType,       /// < Resource group
-        ResourceSectionType,            /// < Resource
-        ResourceMethodSectionType,      /// < Resource & Action combined (abbrev)
-        ActionSectionType,              /// < Action
-        RequestSectionType,             /// < Request
-        RequestBodySectionType,         /// < Request & Payload body combined (abbrev)
-        ResponseSectionType,            /// < Response
-        ResponseBodySectionType,        /// < Response & Body combined (abbrev)
-        ObjectSectionType,              /// < Object (deprecated)
-        ObjectBodySectionType,          /// < Object & Body combined (abbrev, deprecated)
-        ModelSectionType,               /// < Model
-        ModelBodySectionType,           /// < Model & Body combined (abbrev)
-        BodySectionType,                /// < Payload Body
-        DanglingBodySectionType,        /// < Dangling Body (unrecognised section considered to be Body)
-        SchemaSectionType,              /// < Payload Schema
-        DanglingSchemaSectionType,      /// < Dangling Schema (unrecognised section considered to be Schema)
-        HeadersSectionType,             /// < Headers
-        ForeignSectionType,             /// < Foreign, unexpected section
-        ParametersSectionType,          /// < Parameters
-        ParameterDefinitionSectionType, /// < One Parameter definition
-        ParameterValuesSectionType      /// < Parameter value enumeration
-    };
-    
-    /** \returns human readable name for given %SectionType */
-    FORCEINLINE std::string SectionName(const SectionType& section) {
-        switch (section) {
-                
-            case ModelSectionType:
-            case ModelBodySectionType:
-                return "model";
-                
-            case ObjectSectionType:
-            case ObjectBodySectionType:
-                return "object";
-                
-            case RequestSectionType:
-            case RequestBodySectionType:
-                return "request";
-                
-            case ResponseSectionType:
-            case ResponseBodySectionType:
-                return "response";
-                
-            case BodySectionType:
-            case DanglingBodySectionType:
-                return "message-body";
-                
-            case SchemaSectionType:
-            case DanglingSchemaSectionType:
-                return "message-schema";
-                
-            case HeadersSectionType:
-                return "headers";
-                
-            default:
-                return "section";
-        }
-    }
-    
-    /** Markdown block iterator */
-    typedef MarkdownBlock::Stack::const_iterator BlockIterator;
-    
-    /**
-     *  \brief SectionType boundaries.
-     *
-     *  A continuous range of markdown blocks <first, second).
-     */
-    typedef std::pair<BlockIterator, BlockIterator> SectionBounds;
-    
-    
-    /**
-     *  \brief  API Blueprint Section Descriptor.
-     */
-    class BlueprintSection {
-        
-    public:
-        BlueprintSection(const SectionBounds& _bounds)
-        : type(UndefinedSectionType), bounds(_bounds), m_parent(NULL) {}
-        
-        BlueprintSection(const SectionType _type,
-                         const SectionBounds& _bounds,
-                         const BlueprintSection& _parent)
-        : type(_type), bounds(_bounds), m_parent(&_parent) {}
-        
-        /** Type of section */
-        const SectionType type;
-        
-        /**
-         *  Maximum boundaries of the section including any subsection.
-         */
-        const SectionBounds bounds;
-        
-        /**
-         *  \return True if section's parent is specified, false otherwise.
-         */
-        bool hasParent() const {
-            return (m_parent != NULL);
-        }
-        
-        /**
-         *  \return Parent section, throws exception if no parent is defined.
-         */
-        const BlueprintSection& parent() const {
-            if (!hasParent())
-                throw "accessing parent of a root blueprint section";
-            return *m_parent;
-        }
-
-    private:
-        BlueprintSection();
-        BlueprintSection(const BlueprintSection&);
-        BlueprintSection& operator=(const BlueprintSection&);
-        
-        const BlueprintSection* m_parent;
-    };
-}
-
-#endif

data/ext/snowcrash/src/DescriptionSectionUtility.h

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