lounge_lizard 0.1.0

data/ext/drafter/ext/snowcrash/src/SectionParser.h

@@ -0,0 +1,246 @@
+//
+//  SectionParser.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/4/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SECTIONPARSER_H
+#define SNOWCRASH_SECTIONPARSER_H
+
+#include <stdexcept>
+#include "SignatureSectionProcessor.h"
+
+namespace snowcrash {
+
+    /**
+     *  Blueprint section parser
+     */
+    template<typename T, typename Adapter>
+    struct SectionParser {
+
+
+        /**
+         *  \brief  Parse a section of blueprint
+         *  \param  node    Initial node to start parsing at
+         *  \param  siblings    Siblings of the initial node
+         *  \param  pd      Parser data
+         *  \param  T       Parsed output
+         *  \return Iterator to the first unparsed block
+         */
+        static MarkdownNodeIterator parse(const MarkdownNodeIterator& node,
+                                          const MarkdownNodes& siblings,
+                                          SectionParserData& pd,
+                                          const ParseResultRef<T>& out) {
+
+            SectionLayout layout = DefaultSectionLayout;
+            MarkdownNodeIterator cur = Adapter::startingNode(node, pd);
+            const MarkdownNodes& collection = Adapter::startingNodeSiblings(node, siblings);
+
+            // Signature node
+            MarkdownNodeIterator lastCur = cur;
+            cur = SectionProcessor<T>::processSignature(cur, collection, pd, layout, out);
+
+            // Exclusive Nested Sections Layout
+            if (layout == ExclusiveNestedSectionLayout) {
+
+                cur = parseNestedSections(cur, collection, pd, out);
+
+                SectionProcessor<T>::finalize(node, pd, out);
+
+                return Adapter::nextStartingNode(node, siblings, cur);
+            }
+
+            // Parser redirect layout
+            if (layout == RedirectSectionLayout) {
+                SectionProcessor<T>::finalize(node, pd, out);
+
+                return Adapter::nextStartingNode(node, siblings, cur);
+            }
+
+            // Default layout
+            if (lastCur == cur)
+                return Adapter::nextStartingNode(node, siblings, cur);
+
+            // Description nodes
+            while(cur != collection.end() &&
+                  SectionProcessor<T>::isDescriptionNode(cur, pd.sectionContext())) {
+
+                lastCur = cur;
+                cur = SectionProcessor<T>::processDescription(cur, collection, pd, out);
+
+                if (lastCur == cur)
+                    return Adapter::nextStartingNode(node, siblings, cur);
+            }
+
+            // Content nodes
+            while(cur != collection.end() &&
+                  SectionProcessor<T>::isContentNode(cur, pd.sectionContext())) {
+
+                lastCur = cur;
+                cur = SectionProcessor<T>::processContent(cur, collection, pd, out);
+
+                if (lastCur == cur)
+                    return Adapter::nextStartingNode(node, siblings, cur);
+            }
+
+            // Nested Sections
+            cur = parseNestedSections(cur, collection, pd, out);
+
+            SectionProcessor<T>::finalize(node, pd, out);
+
+            return Adapter::nextStartingNode(node, siblings, cur);
+        }
+
+
+        /** Parse nested sections */
+        static MarkdownNodeIterator parseNestedSections(const MarkdownNodeIterator& node,
+                                                        const MarkdownNodes& collection,
+                                                        SectionParserData& pd,
+                                                        const ParseResultRef<T>& out) {
+
+            MarkdownNodeIterator cur = node;
+            MarkdownNodeIterator lastCur = cur;
+
+            SectionType lastSectionType = UndefinedSectionType;
+
+            SectionProcessor<T>::preprocessNestedSections(node, collection, pd, out);
+
+            // Nested sections
+            while (cur != collection.end()) {
+
+                lastCur = cur;
+                SectionType nestedType = SectionProcessor<T>::nestedSectionType(cur);
+
+                pd.sectionsContext.push_back(nestedType);
+
+                if (nestedType != UndefinedSectionType) {
+                    cur = SectionProcessor<T>::processNestedSection(cur, collection, pd, out);
+                }
+                else if (Adapter::nextSkipsUnexpected ||
+                         SectionProcessor<T>::isUnexpectedNode(cur, pd.sectionContext())) {
+
+                    cur = SectionProcessor<T>::processUnexpectedNode(cur, collection, pd, lastSectionType, out);
+                }
+
+                if (cur != collection.end() &&
+                    (pd.sectionContext() != UndefinedSectionType ||
+                     (cur->type != mdp::ParagraphMarkdownNodeType &&
+                      cur->type != mdp::CodeMarkdownNodeType))) {
+
+                    lastSectionType = pd.sectionContext();
+                }
+
+                pd.sectionsContext.pop_back();
+
+                if (lastCur == cur)
+                    break;
+            }
+
+            return cur;
+        }
+    };
+
+    /** Parser Adapter for parsing header-defined sections */
+    struct HeaderSectionAdapter {
+
+        /** \return Node to start parsing with */
+        static const MarkdownNodeIterator startingNode(const MarkdownNodeIterator& seed,
+                                                       const SectionParserData& pd) {
+            if (seed->type != mdp::HeaderMarkdownNodeType) {
+                // ERR: Expected header
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(seed->sourceMap, pd.sourceCharacterIndex);
+                throw Error("expected header block, e.g. '# <text>'", BusinessError, sourceMap);
+            }
+
+            return seed;
+        }
+
+        /** \return Collection of siblings to starting Node */
+        static const MarkdownNodes& startingNodeSiblings(const MarkdownNodeIterator& seed,
+                                                         const MarkdownNodes& siblings) {
+            return siblings;
+        }
+
+        /** \return Starting node for next parsing */
+        static const MarkdownNodeIterator nextStartingNode(const MarkdownNodeIterator& seed,
+                                                           const MarkdownNodes& siblings,
+                                                           const MarkdownNodeIterator& cur) {
+            return cur;
+        }
+
+        /**
+         *  \brief Adapter Markdown node skipping behavior trait.
+         *
+         *  Adapter trait signalizing that the adapter can possibly skip some Markdown nodes on a nextStartingNode() call.
+         *  If set to true, a call to nextStartingNode() can skip some nodes causing some information loss. False otherwise.
+         */
+        static const bool nextSkipsUnexpected = false;
+    };
+
+    /** Parser Adapter for parsing list-defined sections */
+    struct ListSectionAdapter {
+
+        static const MarkdownNodeIterator startingNode(const MarkdownNodeIterator& seed,
+                                                       const SectionParserData& pd) {
+            if (seed->type != mdp::ListItemMarkdownNodeType) {
+                // ERR: Expected list item
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(seed->sourceMap, pd.sourceCharacterIndex);
+                throw Error("expected list item block, e.g. '+ <text>'", BusinessError, sourceMap);
+            }
+
+            for (auto it = seed->children().begin() ; it != seed->children().end() ; ++it) {
+                if (it->sourceMap.begin()->length != 0) {
+                    return it;
+                }
+            }
+
+            // there are no parseable items, let it pass in old manner
+            return seed->children().begin(); 
+        }
+
+        static const MarkdownNodes& startingNodeSiblings(const MarkdownNodeIterator& seed,
+                                                         const MarkdownNodes& siblings) {
+            return seed->children();
+        }
+
+        static const MarkdownNodeIterator nextStartingNode(const MarkdownNodeIterator& seed,
+                                                           const MarkdownNodes& siblings,
+                                                           const MarkdownNodeIterator& cur) {
+            if (seed == siblings.end())
+                return seed;
+
+            return ++MarkdownNodeIterator(seed);
+        }
+
+        static const bool nextSkipsUnexpected = true;
+    };
+
+    /** Parser Adapter for parsing blueprint sections */
+    struct BlueprintSectionAdapter {
+
+        /** \return Node to start parsing with */
+        static const MarkdownNodeIterator startingNode(const MarkdownNodeIterator& seed,
+                                                       const SectionParserData& pd) {
+            return seed;
+        }
+
+        /** \return Collection of siblings to starting Node */
+        static const MarkdownNodes& startingNodeSiblings(const MarkdownNodeIterator& seed,
+                                                         const MarkdownNodes& siblings) {
+            return siblings;
+        }
+
+        /** \return Starting node for next parsing */
+        static const MarkdownNodeIterator nextStartingNode(const MarkdownNodeIterator& seed,
+                                                           const MarkdownNodes& siblings,
+                                                           const MarkdownNodeIterator& cur) {
+            return cur;
+        }
+
+        static const bool nextSkipsUnexpected = false;
+    };
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/SectionParserData.h

@@ -0,0 +1,109 @@
+//
+//  SectionParserData.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/21/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SECTIONPARSERDATA_H
+#define SNOWCRASH_SECTIONPARSERDATA_H
+
+#include "ModelTable.h"
+#include "BlueprintSourcemap.h"
+#include "Section.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
+        ExportSourcemapOption = (1 << 2)        /// < Export source maps AST
+    };
+
+    typedef unsigned int BlueprintParserOptions;
+
+    /**
+     *  \brief Section Parser Data
+     *
+     *  State of the parser.
+     */
+    struct SectionParserData {
+        SectionParserData(BlueprintParserOptions opts,
+                          const mdp::ByteBuffer& src,
+                          const Blueprint& bp)
+        : options(opts), sourceData(src), blueprint(bp) {}
+
+        /** Parser Options */
+        BlueprintParserOptions options;
+
+        /** Named Types */
+        std::vector<mson::NamedType> msonTypesTable;
+
+        /** Table of named types and resolved base types */
+        mson::NamedTypeBaseTable namedTypeBaseTable;
+
+        /** Table mapping named type to sub types */
+        mson::NamedTypeInheritanceTable namedTypeInheritanceTable;
+
+        /** Table mapping named types to their dependent named types */
+        mson::NamedTypeDependencyTable namedTypeDependencyTable;
+
+        /** Variable to store the current named type */
+        mson::Literal namedTypeContext;
+
+        /** Model Table */
+        ModelTable modelTable;
+
+        /** Model Table Sourcemap */
+        ModelSourceMapTable modelSourceMapTable;
+
+        /** Source Data */
+        const mdp::ByteBuffer& sourceData;
+
+        /** Source - map of bytes to character position - performance optimalization */
+        mdp::ByteBufferCharacterIndex sourceCharacterIndex;
+
+        /** AST being parsed **/
+        const Blueprint& blueprint;
+
+        /** Sections Context */
+        typedef std::vector<SectionType> SectionsStack;
+        SectionsStack sectionsContext;
+
+        /** \returns Actual Section Context */
+        SectionType sectionContext() const {
+            return (sectionsContext.empty()) ? UndefinedSectionType : sectionsContext.back();
+        }
+
+        /** \returns Parent Section Context */
+        SectionType parentSectionContext() const {
+            if (sectionsContext.empty())
+                return UndefinedSectionType;
+
+            size_t size = sectionsContext.size();
+
+            if (size == 1)
+                return sectionsContext.back();
+            else
+                return sectionsContext[size-2];
+        }
+
+        /** \returns True if exporting source maps */
+        bool exportSourceMap() const {
+            return options & ExportSourcemapOption;
+        }
+
+    private:
+        SectionParserData();
+        SectionParserData(const SectionParserData&);
+        SectionParserData& operator=(const SectionParserData&);
+    };
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/SectionProcessor.h

@@ -0,0 +1,299 @@
+//
+//  SectionProcessor.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/14/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SECTIONPROCESSOR_H
+#define SNOWCRASH_SECTIONPROCESSOR_H
+
+#include "SectionParserData.h"
+#include "SourceAnnotation.h"
+#include "Signature.h"
+
+// Use the following macro whenever a section doesn't have description
+#define NO_SECTION_DESCRIPTION(T)\
+static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,\
+                                               const MarkdownNodes& siblings,\
+                                               SectionParserData& pd,\
+                                               const ParseResultRef<T>& out) {\
+    return node;\
+}\
+\
+static bool isDescriptionNode(const MarkdownNodeIterator& node,\
+                              SectionType sectionType) {\
+    return false;\
+}\
+
+namespace snowcrash {
+
+    using mdp::MarkdownNode;
+    using mdp::MarkdownNodes;
+    using mdp::MarkdownNodeIterator;
+
+    typedef Collection<SectionType>::type SectionTypes;
+
+    /**
+     *  Layout of the section being parsed
+     */
+    enum SectionLayout {
+        DefaultSectionLayout,          /// Default Section Layout: Signature > Description > Content > Nested
+        ExclusiveNestedSectionLayout,  /// Section is composed of nested sections only
+        RedirectSectionLayout          /// Section should be parsed by another parser as whole
+    };
+
+    /**
+     *  \brief Complete compound product of parsing
+     *
+     *  This structure owns all of the product data. As such
+     *  it shouldn't be used internally unless there is a need
+     *  for storing complete parser data. See %IntermediateParseResult.
+     */
+    template<typename T>
+    struct ParseResult {
+
+        ParseResult(const Report& report_ = Report())
+        : report(report_) {}
+
+        Report report;           /// Parser's report
+        T node;                  /// Parsed AST node
+        SourceMap<T> sourceMap;  /// Parsed AST node source map
+    };
+
+    /**
+     *  \brief Partial product of parsing.
+     *
+     *  This structure owns the node being parsed and its source map.
+     *  Unlike %ParseResult it relies on shared parser report data making it
+     *  ideal for holding temporary results while parsing items of a collection.
+     */
+    template<typename T>
+    struct IntermediateParseResult {
+
+        explicit IntermediateParseResult(Report& report_)
+        : report(report_) {}
+
+        Report& report;
+        T node;
+        SourceMap<T> sourceMap;
+    };
+
+    /**
+     *  \brief Reference wrapper for parsing data product
+     *
+     *  Reference wrapper for %ParseResult and %IntermediateParseResult.
+     */
+    template<typename T>
+    struct ParseResultRef {
+
+        ParseResultRef(ParseResult<T>& parseResult)
+        : report(parseResult.report), node(parseResult.node), sourceMap(parseResult.sourceMap) {}
+
+        ParseResultRef(IntermediateParseResult<T>& parseResult)
+        : report(parseResult.report), node(parseResult.node), sourceMap(parseResult.sourceMap) {}
+
+        ParseResultRef(Report& report_, T& node_, SourceMap<T>& sourceMap_)
+        : report(report_), node(node_), sourceMap(sourceMap_) {}
+
+        Report& report;
+        T& node;
+        SourceMap<T>& sourceMap;
+
+    private:
+        ParseResultRef();
+    };
+
+    /*
+     * Forward Declarations
+     */
+    template<typename T>
+    struct SectionProcessor;
+
+    /**
+     *  \brief  Section Processor Base
+     *
+     *  Defines section processor interface alongised with its default
+     *  behavior.
+     */
+    template<typename T>
+    struct SectionProcessorBase {
+
+        /**
+         *  \brief Process section signature Markdown node
+         *  \param node     Node to process
+         *  \param siblings Siblings of the node being processed
+         *  \param pd       Section parser state
+         *  \param report   Process log report
+         *  \param out      Processed output
+         *  \return Result of the process operation
+         */
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     const ParseResultRef<T>& out) {
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        /** Process section description Markdown node */
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<T>& out) {
+
+            if (!out.node.description.empty()) {
+                TwoNewLines(out.node.description);
+            }
+
+            mdp::ByteBuffer content = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+
+            if (pd.exportSourceMap() && !content.empty()) {
+                out.sourceMap.description.sourceMap.append(node->sourceMap);
+            }
+
+            TrimString(content);
+            out.node.description += content;
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        /** Process section-specific content Markdown node */
+        static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
+                                                   const MarkdownNodes& siblings,
+                                                   SectionParserData& pd,
+                                                   const ParseResultRef<T>& out) {
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        /**
+         * Pre-process for nested sections, basically a look-ahead before processing nested sections
+         * Only used by BlueprintParser for now
+         */
+        static void preprocessNestedSections(const MarkdownNodeIterator& node,
+                                             const MarkdownNodes& siblings,
+                                             SectionParserData& pd,
+                                             const ParseResultRef<T>& out) {
+        }
+
+        /**
+         *  \brief Process nested sections Markdown node(s)
+         *  \param node     Node to process
+         *  \param siblings Siblings of the node being processed
+         *  \param pd       Section parser state
+         *  \param report   Process log report
+         *  \param out      Processed output
+         */
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<T>& out) {
+
+            return node;
+        }
+
+        /** Process unexpected Markdown node */
+        static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
+                                                          const MarkdownNodes& siblings,
+                                                          SectionParserData& pd,
+                                                          SectionType& lastSectionType,
+                                                          const ParseResultRef<T>& out) {
+
+            // WARN: Ignoring unexpected node
+            std::stringstream ss;
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+
+            if (node->type == mdp::HeaderMarkdownNodeType) {
+                ss << "unexpected header block, expected a group, resource or an action definition";
+                ss << ", e.g. '# Group <name>', '# <resource name> [<URI>]' or '# <HTTP method> <URI>'";
+            } else {
+                ss << "ignoring unrecognized block";
+            }
+
+            out.report.warnings.push_back(Warning(ss.str(),
+                                                  IgnoringWarning,
+                                                  sourceMap));
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        /** Final validation after processing */
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<T>& out) {
+        }
+
+        /** \return True if the node is a section description node */
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            if (SectionProcessor<T>::isContentNode(node, sectionType) ||
+                SectionProcessor<T>::nestedSectionType(node) != UndefinedSectionType) {
+                return false;
+            }
+
+            SectionType keywordSectionType = SectionKeywordSignature(node);
+
+            if (keywordSectionType == UndefinedSectionType) {
+                return true;
+            }
+
+            SectionTypes upperTypes = SectionProcessor<T>::upperSectionTypes();
+
+            if (std::find(upperTypes.begin(), upperTypes.end(), keywordSectionType) != upperTypes.end()) {
+                // Node is a keyword defined section defined in an upper level section
+                return false;
+            }
+
+            return true;
+        }
+
+        /** \return True if the node is a section-specific content node */
+        static bool isContentNode(const MarkdownNodeIterator& node,
+                                  SectionType sectionType) {
+            return false;
+        }
+
+        /** \return True if the node is unexpected in the current context */
+        static bool isUnexpectedNode(const MarkdownNodeIterator& node,
+                                     SectionType sectionType) {
+
+            SectionType keywordSectionType = SectionKeywordSignature(node);
+            SectionTypes upperTypes = SectionProcessor<T>::upperSectionTypes();
+
+            if (std::find(upperTypes.begin(), upperTypes.end(), keywordSectionType) == upperTypes.end()) {
+                // Node is not a section that is upper level
+                return true;
+            }
+
+            return (keywordSectionType == UndefinedSectionType);
+        }
+
+        /** \return All upper level sections of the section */
+        static SectionTypes upperSectionTypes() {
+            return SectionTypes();
+        }
+
+        /** \return %SectionType of the node */
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+            return UndefinedSectionType;
+        }
+
+        /** \return Nested %SectionType of the node */
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+            return UndefinedSectionType;
+        }
+    };
+
+    /**
+     *  Default Section Processor
+     */
+    template<typename T>
+    struct SectionProcessor : public SectionProcessorBase<T> {
+    };
+}
+
+#endif