redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/{src → ext/markdown-parser/src}/MarkdownParser.h

@@ -1,87 +1,97 @@
 //
 //  MarkdownParser.h
-//  snowcrash
+//  markdownparser
 //
-//  Created by Zdenek Nemec on 4/15/13.
-//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//  Created by Zdenek Nemec on 4/18/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
 //
 
-#ifndef SNOWCRASH_MARKDOWNPARSER_H
-#define SNOWCRASH_MARKDOWNPARSER_H
+#ifndef MARKDOWNPARSER_MARKDOWNPARSER_H
+#define MARKDOWNPARSER_MARKDOWNPARSER_H
 
-#include "ParserCore.h"
-#include "SourceAnnotation.h"
-#include "MarkdownBlock.h"
+#include "ByteBuffer.h"
+#include "MarkdownNode.h"
 #include "markdown.h"
 
-namespace snowcrash {
+namespace mdp {
     
-    //
-    // Markdown Parser
-    //
+    /** 
+     *  GitHub-flavored Markdown Parser
+     */
     class MarkdownParser {
     public:
-        // Default sundown parser configuration
-        static const size_t OutputUnitSize; // = 64;
-        static const size_t MaxNesting;// = 16;
-        static const int ParserExtensions;// = MKDEXT_FENCED_CODE | MKDEXT_NO_INTRA_EMPHASIS /*| MKDEXT_TABLES */;
+        MarkdownParser();
+        MarkdownParser(const MarkdownParser&);
+        MarkdownParser& operator=(const MarkdownParser&);
+        
+        /**
+         *  \brief Parse source buffer
+         *
+         *  \param source   Markdown source data to be parsed
+         *  \param ast      Parsed AST (root node)
+         */
+        void parse(const ByteBuffer& source, MarkdownNode& ast);
         
-        // Parse source Markdown into Markdown AST
-        void parse(const SourceData& source, Result& result, MarkdownBlock::Stack& markdown);
-    
     private:
+        MarkdownNode* m_workingNode;
+        bool m_listBlockContext;
+        const ByteBuffer* m_source;
+        size_t m_sourceLength;
+        
+        static const size_t OutputUnitSize;
+        static const size_t MaxNesting;
+        static const int ParserExtensions;
+
         typedef sd_callbacks RenderCallbacks;
-        typedef void * RenderCallbackData;
-    
         RenderCallbacks renderCallbacks();
-        RenderCallbackData renderCallbackData();
         
-        MarkdownBlock::Stack m_renderStack;
+        typedef void * RenderCallbackData;
+        RenderCallbackData renderCallbackData();
         
         // Header
         static void renderHeader(struct buf *ob, const struct buf *text, int level, void *opaque);
-        void renderHeader(const std::string& text, int level);
+        void renderHeader(const ByteBuffer& text, int level);
         
         // List
         static void beginList(int flags, void *opaque);
         void beginList(int flags);
         
         static void renderList(struct buf *ob, const struct buf *text, int flags, void *opaque);
-        void renderList(const std::string& text, int flags);
+        void renderList(const ByteBuffer& text, int flags);
         
         // List item
         static void beginListItem(int flags, void *opaque);
         void beginListItem(int flags);
         
         static void renderListItem(struct buf *ob, const struct buf *text, int flags, void *opaque);
-        void renderListItem(const std::string& text, int flags);
+        void renderListItem(const ByteBuffer& text, int flags);
         
         // Code block
         static void renderBlockCode(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque);
-        void renderBlockCode(const std::string& text, const std::string& language);
+        void renderBlockCode(const ByteBuffer& text, const ByteBuffer& language);
         
         // Paragraph
         static void renderParagraph(struct buf *ob, const struct buf *text, void *opaque);
-        void renderParagraph(const std::string& text);
+        void renderParagraph(const ByteBuffer& text);
         
         // Horizontal Rule
         static void renderHorizontalRule(struct buf *ob, void *opaque);
         void renderHorizontalRule();
-
+        
         // HTML
         static void renderHTML(struct buf *ob, const struct buf *text, void *opaque);
-        void renderHTML(const std::string& text);
-    
+        void renderHTML(const ByteBuffer& text);
+        
         // Quote
         static void beginQuote(void *opaque);
         void beginQuote();
-    
+        
         static void renderQuote(struct buf *ob, const struct buf *text, void *opaque);
         void renderQuote(const std::string& text);
         
         // Source maps
         static void blockDidParse(const src_map* map, const uint8_t *txt_data, size_t size, void *opaque);
-        void blockDidParse(const SourceDataBlock& sourceMap);
+        void blockDidParse(const BytesRangeSet& sourceMap);
     };
 }
 

data/ext/snowcrash/snowcrash.gyp

@@ -2,25 +2,52 @@
   "includes": [
     "common.gypi"
   ],
-  
   'targets' : [
     {
-      'target_name': 'sundown',
+      'target_name': 'libsundown',
       'type': 'static_library',
       'include_dirs': [
-        'sundown/src',
-        'sundown/html',
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/markdown-parser/ext/sundown/html'
       ],
       'sources': [
-        'sundown/src/autolink.c',
-        'sundown/src/buffer.c',
-        'sundown/html/houdini_href_e.c',
-        'sundown/html/houdini_html_e.c',
-        'sundown/html/html.c',
-        'sundown/html/html_smartypants.c',
-        'sundown/src/markdown.c',
-        'sundown/src/stack.c',
-        'sundown/src/src_map.c'
+        'ext/markdown-parser/ext/sundown/src/autolink.c',
+        'ext/markdown-parser/ext/sundown/src/autolink.h',
+        'ext/markdown-parser/ext/sundown/src/buffer.c',
+        'ext/markdown-parser/ext/sundown/src/buffer.h',
+        'ext/markdown-parser/ext/sundown/src/html_blocks.h',
+        'ext/markdown-parser/ext/sundown/src/markdown.c',
+        'ext/markdown-parser/ext/sundown/src/markdown.h',
+        'ext/markdown-parser/ext/sundown/src/src_map.c',
+        'ext/markdown-parser/ext/sundown/src/src_map.h',
+        'ext/markdown-parser/ext/sundown/src/stack.c',
+        'ext/markdown-parser/ext/sundown/src/stack.h',
+        'ext/markdown-parser/ext/sundown/html/houdini.h',
+        'ext/markdown-parser/ext/sundown/html/houdini_href_e.c',
+        'ext/markdown-parser/ext/sundown/html/houdini_html_e.c',
+        'ext/markdown-parser/ext/sundown/html/html.c',
+        'ext/markdown-parser/ext/sundown/html/html.h',
+        'ext/markdown-parser/ext/sundown/html/html_smartypants.c'
+      ]
+    },
+    {
+      'target_name': 'libmarkdownparser',
+      'type': 'static_library',
+      'include_dirs': [
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/markdown-parser/ext/sundown/html'
+        'ext/markdown-parser/src',
+      ],
+      'sources': [
+        'ext/markdown-parser/src/ByteBuffer.cc',
+        'ext/markdown-parser/src/ByteBuffer.h',
+        'ext/markdown-parser/src/MarkdownNode.cc',
+        'ext/markdown-parser/src/MarkdownNode.h',
+        'ext/markdown-parser/src/MarkdownParser.cc',
+        'ext/markdown-parser/src/MarkdownParser.h'
+      ],
+      'dependencies': [
+          'libsundown'
       ]
     },
     {
@@ -28,34 +55,64 @@
       'type': '<(libsnowcrash_type)',
       'include_dirs': [
         'src',
-        'sundown/src',
-        'sundown/src/html'
+        'ext/markdown-parser/src',
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/markdown-parser/ext/sundown/html'
       ],
       'sources': [
+        'src/CBlueprint.cc',
+        'src/CBlueprint.h',
+        'src/CSourceAnnotation.cc',
+        'src/CSourceAnnotation.h',
         'src/HTTP.cc',
-        'src/MarkdownBlock.cc',
-        'src/MarkdownParser.cc',
-        'src/Parser.cc',
-        'src/ParserCore.cc',
-        'src/RegexMatch.h',
+        'src/HTTP.h',
+        'src/Section.cc',
+        'src/Section.h',
         'src/Serialize.cc',
         'src/Serialize.h',
         'src/SerializeJSON.cc',
+        'src/SerializeJSON.h',
         'src/SerializeYAML.cc',
-        'src/UriTemplateParser.cc',
+        'src/SerializeYAML.h',
+        'src/Signature.cc',
+        'src/Signature.h',
         'src/snowcrash.cc',
+        'src/snowcrash.h',
         'src/csnowcrash.cc',
-        'src/CBlueprint.cc',
-        'src/CSourceAnnotation.cc'
+        'src/csnowcrash.h',
+        'src/UriTemplateParser.cc',
+        'src/UriTemplateParser.h',
+        'src/PayloadParser.h',
+        'src/SectionParserData.h',
+        'src/ActionParser.h',
+        'src/AssetParser.h',
+        'src/Blueprint.h',
+        'src/BlueprintParser.h',
+        'src/BlueprintUtility.h',
+        'src/CodeBlockUtility.h',
+        'src/HeadersParser.h',
+        'src/ParameterParser.h',
+        'src/ParametersParser.h',
+        'src/Platform.h',
+        'src/RegexMatch.h',
+        'src/ResourceGroupParser.h',
+        'src/ResourceParser.h',
+        'src/SectionParser.h',
+        'src/SectionProcessor.h',
+        'src/SourceAnnotation.h',
+        'src/StringUtility.h',
+        'src/SymbolTable.h',
+        'src/ValuesParser.h',
+        'src/Version.h'
       ],
       'conditions': [
-        [ 'OS=="win"', 
-          { 'sources': [ 'src/win/RegexMatch.cc' ] }, 
+        [ 'OS=="win"',
+          { 'sources': [ 'src/win/RegexMatch.cc' ] },
           { 'sources': [ 'src/posix/RegexMatch.cc' ] } # OS != Windows
         ]
       ],
       'dependencies': [
-          'sundown'
+          'libmarkdownparser'
       ]
     },
     {
@@ -65,45 +122,44 @@
         'src',
         'test',
         'test/vendor/Catch/include',
-        'sundown/src',
-        'sundown/src/html'
+        'ext/markdown-parser/src',
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/markdown-parser/ext/sundown/html'
       ],
       'sources': [
         'test/test-ActionParser.cc',
         'test/test-AssetParser.cc',
         'test/test-Blueprint.cc',
         'test/test-BlueprintParser.cc',
-        'test/test-HeaderParser.cc',
+        'test/test-HeadersParser.cc',
         'test/test-Indentation.cc',
-        'test/test-ListUtility.cc',
-        'test/test-MarkdownBlock.cc',
-        'test/test-MarkdownParser.cc',
-        'test/test-ParameterDefinitonParser.cc',
+        'test/test-ParameterParser.cc',
         'test/test-ParametersParser.cc',
-        'test/test-Parser.cc',
         'test/test-PayloadParser.cc',
         'test/test-RegexMatch.cc',
-        'test/test-ResouceGroupParser.cc',
         'test/test-ResourceParser.cc',
+        'test/test-ResourceGroupParser.cc',
+        'test/test-SectionParser.cc',
         'test/test-SymbolIdentifier.cc',
         'test/test-SymbolTable.cc',
+        'test/test-UriTemplateParser.cc',
+        'test/test-ValuesParser.cc',
         'test/test-Warnings.cc',
         'test/test-csnowcrash.cc',
-        'test/test-UriTemplateParser.cc',
         'test/test-snowcrash.cc'
       ],
       'dependencies': [
         'libsnowcrash',
-        'sundown'
+        'libmarkdownparser'
       ]
     },
-
     {
       'target_name': 'snowcrash',
       'type': 'executable',
       'include_dirs': [
         'src',
         'src/snowcrash',
+        'ext/markdown-parser/src',
         'cmdline'
       ],
       'sources': [
@@ -111,31 +167,26 @@
       ],
       'dependencies': [
         'libsnowcrash',
-        'sundown'
+        'libmarkdownparser'
       ]
-    }
-  ],
-  'conditions': [
-    ['OS in "mac linux"', {
-      'targets': [
-        {
-          'target_name': 'perf-libsnowcrash',
-          'type': 'executable',
-          'include_dirs': [
-            'src',
-            'cmdline',
-            'test',
-            'test/performance',
-          ],
-          'sources': [
-            'test/performance/perf-snowcrash.cc'
-          ],
-          'dependencies': [
-            'libsnowcrash',
-            'sundown'
-          ]
-        }
+    },
+    {
+      'target_name': 'perf-libsnowcrash',
+      'type': 'executable',
+      'include_dirs': [
+        'src',
+        'ext/markdown-parser/src',
+        'cmdline',
+        'test',
+        'test/performance',
+      ],
+      'sources': [
+        'test/performance/perf-snowcrash.cc'
+      ],
+      'dependencies': [
+        'libsnowcrash',
+        'libmarkdownparser'
       ]
-    }]
-  ]  
+    }
+  ]
 }

data/ext/snowcrash/src/ActionParser.h

@@ -9,468 +9,331 @@
 #ifndef SNOWCRASH_ACTIONPARSER_H
 #define SNOWCRASH_ACTIONPARSER_H
 
-#include "BlueprintParserCore.h"
-#include "Blueprint.h"
-#include "RegexMatch.h"
-#include "PayloadParser.h"
-#include "HeaderParser.h"
-#include "ParametersParser.h"
 #include "HTTP.h"
-#include "DescriptionSectionUtility.h"
+#include "SectionParser.h"
+#include "ParametersParser.h"
+#include "PayloadParser.h"
+#include "RegexMatch.h"
+
+namespace snowcrash {
 
-namespace snowcrashconst {
-    
     /** Nameless action matching regex */
     const char* const ActionHeaderRegex = "^[[:blank:]]*" HTTP_REQUEST_METHOD "[[:blank:]]*" URI_TEMPLATE "?$";
-    
+
     /** Named action matching regex */
     const char* const NamedActionHeaderRegex = "^[[:blank:]]*" SYMBOL_IDENTIFIER "\\[" HTTP_REQUEST_METHOD "]$";
-}
 
-namespace snowcrash {
+    /** Internal type alias for Collection of Action */
+    typedef Collection<Action>::type Actions;
+
+    typedef Collection<Action>::const_iterator ActionIterator;
     
-    // Method signature
-    enum ActionSignature {
-        UndefinedActionSignature,
-        NoActionSignature,
-        MethodActionSignature,      // # GET
-        MethodURIActionSignature,   // # GET /uri
-        NamedActionSignature        // # My Method [GET]
+    /** Action Definition Type */
+    enum ActionType {
+        NotActionType = 0,
+        DependentActionType,      /// Action isn't fully defined, depends on parents resource URI
+        CompleteActionType,       /// Action is fully defined including its URI
+        UndefinedActionType = -1
     };
-    
-    // Query method signature
-    FORCEINLINE ActionSignature GetActionSignature(const MarkdownBlock& block,
-                                                   Name& name,
-                                                   HTTPMethod& method) {
-        if (block.type != HeaderBlockType ||
-            block.content.empty())
-            return NoActionSignature;
-        
-        CaptureGroups captureGroups;
-        if (RegexCapture(block.content, snowcrashconst::ActionHeaderRegex, captureGroups, 3)) {
-            // Nameless action
-            method = captureGroups[1];
-            URITemplate uri = captureGroups[2];
-            return (uri.empty()) ? MethodActionSignature : MethodURIActionSignature;
-        }
-        else if (RegexCapture(block.content, snowcrashconst::NamedActionHeaderRegex, captureGroups, 3)) {
-            // Named action
-            name = captureGroups[1];
-            TrimString(name);
-            method = captureGroups[2];
-            return NamedActionSignature;
+
+    /**
+     * Action Section processor
+     */
+    template<>
+    struct SectionProcessor<Action> : public SectionProcessorBase<Action> {
+
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     Report& report,
+                                                     Action& out) {
+
+            actionHTTPMethodAndName(node, out.method, out.name);
+            TrimString(out.name);
+
+            mdp::ByteBuffer remainingContent;
+            GetFirstLine(node->text, remainingContent);
+
+            if (!remainingContent.empty()) {
+                out.description += remainingContent;
+            }
+
+            return ++MarkdownNodeIterator(node);
         }
-        
-        return NoActionSignature;
-    }
 
-    // Returns true if block has HTTP Method signature, false otherwise
-    FORCEINLINE bool HasActionSignature(const MarkdownBlock& block) {
-        
-        if (block.type != HeaderBlockType ||
-            block.content.empty())
-            return false;
-        
-        Name name;
-        HTTPMethod method;
-        return GetActionSignature(block, name, method) != NoActionSignature;
-    }
-    
-    // Finds an action inside resource
-    FORCEINLINE Collection<Action>::iterator FindAction(Resource& resource,
-                                                        const Action& action) {
-        return std::find_if(resource.actions.begin(),
-                            resource.actions.end(),
-                            std::bind2nd(MatchAction<Action>(), action));
-    }
-    
-    //
-    // Classifier of internal list items, Payload context
-    //
-    template <>
-    FORCEINLINE SectionType ClassifyInternaListBlock<Action>(const BlockIterator& begin,
-                                                             const BlockIterator& end) {
-        if (HasHeaderSignature(begin, end))
-            return HeadersSectionType;
-        
-        if (HasParametersSignature(begin, end))
-            return ParametersSectionType;
-        
-        Name name;
-        SourceData mediaType;
-        PayloadSignature payload = GetPayloadSignature(begin, end, name, mediaType);
-        if (payload == RequestPayloadSignature)
-            return RequestSectionType;
-        else if (payload == ResponsePayloadSignature)
-            return ResponseSectionType;
-        else if (payload == ObjectPayloadSignature)
-            return ObjectSectionType;
-        else if (payload == ModelPayloadSignature)
-            return ModelSectionType;
-        
-        return UndefinedSectionType;
-    }
-    
-    /** Children blocks classifier */
-    template <>
-    FORCEINLINE SectionType ClassifyChildrenListBlock<Action>(const BlockIterator& begin,
-                                                              const BlockIterator& end) {
-        
-        SectionType type = ClassifyInternaListBlock<Action>(begin, end);
-        if (type != UndefinedSectionType)
-            return type;
-        
-        type = ClassifyChildrenListBlock<HeaderCollection>(begin, end);
-        if (type != UndefinedSectionType)
-            return type;
-        
-        type = ClassifyChildrenListBlock<ParameterCollection>(begin, end);
-        if (type != UndefinedSectionType)
-            return type;
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         Report& report,
+                                                         Action& out) {
 
-        type = ClassifyChildrenListBlock<Payload>(begin, end);
-        if (type != UndefinedSectionType)
-            return type;
-        
-        return UndefinedSectionType;
-    }
-    
-    //
-    // Block Classifier, Action Context
-    //
-    template <>
-    FORCEINLINE SectionType ClassifyBlock<Action>(const BlockIterator& begin,
-                                              const BlockIterator& end,
-                                              const SectionType& context) {
-
-        if (HasActionSignature(*begin))
-            return (context == UndefinedSectionType) ? ActionSectionType : UndefinedSectionType;
-        
-        if (HasResourceSignature(*begin) ||
-            HasResourceGroupSignature(*begin))
-            return UndefinedSectionType;
-        
-        SectionType listSection = ClassifyInternaListBlock<Action>(begin, end);
-        if (listSection != UndefinedSectionType)
-            return listSection;
-        
-        // Unrecognized list item at this level
-        if (begin->type == ListItemBlockBeginType)
-            return ForeignSectionType;
-        
-        return (context == ActionSectionType) ? ActionSectionType : UndefinedSectionType;
-    }
-    
-    //
-    // Action SectionType Parser
-    //
-    template<>
-    struct SectionParser<Action> {
-        
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               Action& action) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            
-            switch (section.type) {
-                case ActionSectionType:
-                    result = HandleActionDescriptionBlock(section, cur, parser, action);
-                    break;
+            SectionType sectionType = pd.sectionContext();
+            MarkdownNodeIterator cur = node;
+            Payload payload;
+            std::stringstream ss;
 
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+
+            switch (sectionType) {
                 case ParametersSectionType:
-                    result = HandleParameters(section, cur, parser, action);
-                    break;
+                    return ParametersParser::parse(node, siblings, pd, report, out.parameters);
 
-                case HeadersSectionType:
-                    result = HandleDeprecatedHeaders(section, cur, parser, action);
-                    break;
-                    
                 case RequestSectionType:
-                case ResponseSectionType:
-                    result = HandlePayload(section, cur, parser, action);
-                    break;
-                    
-                case ForeignSectionType:
-                    result = HandleForeignSection<Action>(section, cur, parser.sourceData);
-                    break;
-                    
-                case UndefinedSectionType:
-                    result.second = CloseList(cur, section.bounds.second);
+                case RequestBodySectionType:
+                    cur = PayloadParser::parse(node, siblings, pd, report, payload);
+
+                    if (out.examples.empty() || !out.examples.back().responses.empty()) {
+                        TransactionExample transaction;
+                        out.examples.push_back(transaction);
+                    }
+
+                    checkPayload(sectionType, sourceMap, payload, out, report);
+
+                    out.examples.back().requests.push_back(payload);
                     break;
-                
-                case ModelSectionType:
-                case ObjectSectionType:
-                    {
-                        // ERR: Unexpected model definition
-                        SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur,
-                                                                                 section.bounds.second,
-                                                                                 section.bounds,                                                                                 
-                                                                                 parser.sourceData);
-                        result.first.error = Error("unexpected model definiton, a model can be only defined in the resource section",
-                                                   SymbolError,
-                                                   sourceBlock);
+
+                case ResponseSectionType:
+                case ResponseBodySectionType:
+                    cur = PayloadParser::parse(node, siblings, pd, report, payload);
+
+                    if (out.examples.empty()) {
+                        TransactionExample transaction;
+                        out.examples.push_back(transaction);
                     }
+
+                    checkPayload(sectionType, sourceMap, payload, out, report);
+
+                    out.examples.back().responses.push_back(payload);
                     break;
-                    
+
+                case HeadersSectionType:
+                    return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, report, out.headers);
+
                 default:
-                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
                     break;
             }
+
+            return cur;
+        }
+
+        static bool isUnexpectedNode(const MarkdownNodeIterator& node,
+                                     SectionType sectionType) {
             
-            return result;
+            if ( SectionProcessor<Asset>::sectionType(node) != UndefinedSectionType) {
+                return true;
+            }
+            
+            return SectionProcessorBase<Action>::isUnexpectedNode(node, sectionType);
         }
         
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             Action& action,
-                             Result& result)
-        {
-            // Consolidate deprecated headers into subsequent payloads
-            if (!action.headers.empty()) {
-                InjectDeprecatedHeaders(action.headers, action.examples);
-                action.headers.clear();
+        static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
+                                                          const MarkdownNodes& siblings,
+                                                          SectionParserData& pd,
+                                                          SectionType& sectionType,
+                                                          Report& report,
+                                                          Action& out) {
+
+            if ((node->type == mdp::ParagraphMarkdownNodeType ||
+                 node->type == mdp::CodeMarkdownNodeType) &&
+                (sectionType == ResponseBodySectionType ||
+                 sectionType == ResponseSectionType) &&
+                !out.examples.empty() &&
+                !out.examples.back().responses.empty()) {
+
+                CodeBlockUtility::addDanglingAsset(node, pd, sectionType, report, out.examples.back().responses.back().body);
+                
+                return ++MarkdownNodeIterator(node);
             }
             
-            // Check whether transaction example request is followed by a response
-            if (action.examples.size() > 1 &&
-                !action.examples.back().requests.empty() &&
-                action.examples.back().responses.empty()) {
-                // WARN: No response for request
+            if ((node->type == mdp::ParagraphMarkdownNodeType ||
+                 node->type == mdp::CodeMarkdownNodeType) &&
+                (sectionType == RequestBodySectionType ||
+                 sectionType == RequestSectionType) &&
+                !out.examples.empty() &&
+                !out.examples.back().requests.empty()) {
                 
-                std::stringstream ss;
-                ss << "action is missing a response for ";
-                if (action.examples.back().requests.back().name.empty())
-                    ss << "a request";
-                else
-                    ss << "the '" << action.examples.back().requests.back().name << "' request";
+                CodeBlockUtility::addDanglingAsset(node, pd, sectionType, report, out.examples.back().requests.back().body);
                 
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(bounds.first, bounds.first, bounds, parser.sourceData);
-                result.warnings.push_back(Warning(ss.str(),
-                                                  EmptyDefinitionWarning,
-                                                  sourceBlock));
+                return ++MarkdownNodeIterator(node);
             }
-        }
-                
-        static ParseSectionResult HandleActionDescriptionBlock(const BlueprintSection& section,
-                                                               const BlockIterator& cur,
-                                                               BlueprintParserCore& parser,
-                                                               Action& action) {
             
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            BlockIterator sectionCur(cur);
+            SectionType assetType = SectionProcessor<Asset>::sectionType(node);
             
-            if (cur->type == HeaderBlockType &&
-                cur == section.bounds.first) {
+            if (assetType != UndefinedSectionType) {
+                
+                // WARN: Ignoring section
+                std::stringstream ss;
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                 
-                GetActionSignature(*cur, action.name, action.method);
-                result.second = ++sectionCur;
-                return result;
+                ss << "Ignoring " << SectionName(assetType) << " list item, ";
+                ss << SectionName(assetType) << " list item is expected to be indented by 4 spaces or 1 tab";
+
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IgnoringWarning,
+                                                  sourceMap));
+
+                return ++MarkdownNodeIterator(node);
             }
             
-            result = ParseDescriptionBlock<Action>(section,
-                                                    sectionCur,
-                                                    parser.sourceData,
-                                                    action);
-            return result;
+            return SectionProcessorBase<Action>::processUnexpectedNode(node, siblings, pd, sectionType, report, out);            
         }
-        
-        /** Parse Parameters section */
-        static ParseSectionResult HandleParameters(const BlueprintSection& section,
-                                                   const BlockIterator& cur,
-                                                   BlueprintParserCore& parser,
-                                                   Action& action) {
-            ParameterCollection parameters;
-            ParseSectionResult result = ParametersParser::Parse(cur,
-                                                                section.bounds.second,
-                                                                section,
-                                                                parser,
-                                                                parameters);
-            if (result.first.error.code != Error::OK)
-                return result;
-            
-            if (parameters.empty()) {
-                BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(snowcrashconst::NoParametersMessage,
-                                                        FormattingWarning,
-                                                        sourceBlock));
-            }
-            else {
-                action.parameters.insert(action.parameters.end(), parameters.begin(), parameters.end());
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::HeaderMarkdownNodeType
+                && !node->text.empty()) {
+
+                mdp::ByteBuffer subject = node->text;
+                TrimString(subject);
+
+                if (RegexMatch(subject, ActionHeaderRegex) ||
+                    RegexMatch(subject, NamedActionHeaderRegex)) {
+
+                    return ActionSectionType;
+                }
             }
-            
-            return result;
+
+            return UndefinedSectionType;
         }
-        
-        /**
-         *  \brief  Parse action payload
-         *  \param  section Actual section being parsed.
-         *  \param  cur     Cursor within the section boundaries.
-         *  \param  parser  A parser's instance.
-         *  \param  action  An output buffer to store parsed payload into.
-         *  \return A block parser section result.
-         */
-        static ParseSectionResult HandlePayload(const BlueprintSection& section,
-                                                const BlockIterator& cur,
-                                                BlueprintParserCore& parser,
-                                                Action& action)
-        {
-            Payload payload;
-            ParseSectionResult result = PayloadParser::Parse(cur,
-                                                             section.bounds.second,
-                                                             section,
-                                                             parser,
-                                                             payload);
-            if (result.first.error.code != Error::OK)
-                return result;
-            
-            // Create transaction example if needed
-            if (action.examples.empty()) {
-                action.examples.push_back(TransactionExample());
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            SectionType nestedType = UndefinedSectionType;
+
+            // Check if parameters section
+            nestedType = SectionProcessor<Parameters>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
             }
-            else if (section.type == RequestSectionType) {
-                // Automatic request response pairing:
-                // If a request follows a response create a new transaction example
-                if (!action.examples.back().responses.empty()) {
-                    action.examples.push_back(TransactionExample());
-                }
+
+            // Check if headers section
+            nestedType = SectionProcessor<Headers>::sectionType(node);
+
+            if (nestedType == HeadersSectionType) {
+                return nestedType;
             }
-            
-            BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-            
-            // Check for duplicate
-            if (IsPayloadDuplicate(section.type, payload, action.examples.back())) {
-                // WARN: duplicate payload
-                std::stringstream ss;
-                ss << SectionName(section.type) << " payload `" << payload.name << "`";
-                ss << " already defined for `" << action.method << "` method";
 
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(ss.str(),
-                                                        DuplicateWarning,
-                                                        sourceBlock));
+            // Check if payload section
+            nestedType = SectionProcessor<Payload>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
             }
 
-            // Check payload integrity
-            CheckPayload(section.type, payload, action.method, nameBlock->sourceMap, parser.sourceData, result.first);
-            
-            // Inject parsed payload into the action
-            if (section.type == RequestSectionType) {
-                action.examples.back().requests.push_back(payload);
+            return UndefinedSectionType;
+        }
+
+        static SectionTypes nestedSectionTypes() {
+            SectionTypes nested, types;
+
+            // Payload & descendants
+            nested.push_back(ResponseBodySectionType);
+            nested.push_back(ResponseSectionType);
+            nested.push_back(RequestBodySectionType);
+            nested.push_back(RequestSectionType);
+
+            types = SectionProcessor<Payload>::nestedSectionTypes();
+            nested.insert(nested.end(), types.begin(), types.end());
+
+            return nested;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             Report& report,
+                             Action& out) {
+
+            if (!out.headers.empty()) {
+
+                SectionProcessor<Headers>::injectDeprecatedHeaders(out.headers, out.examples);
+                out.headers.clear();
             }
-            else if (section.type == ResponseSectionType) {
-                action.examples.back().responses.push_back(payload);
+
+            if (out.examples.empty()) {
+
+                // WARN: No response for action
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning("action is missing a response",
+                                                  EmptyDefinitionWarning,
+                                                  sourceMap));
+            } else if (!out.examples.empty() &&
+                !out.examples.back().requests.empty() &&
+                out.examples.back().responses.empty()) {
+
+                // WARN: No response for request
+                std::stringstream ss;
+                ss << "action is missing a response for ";
+
+                if (out.examples.back().requests.back().name.empty()) {
+                    ss << "a request";
+                } else {
+                    ss << "the '" << out.examples.back().requests.back().name << "' request";
+                }
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  EmptyDefinitionWarning,
+                                                  sourceMap));
             }
-            
-            // Check header duplicates
-            CheckHeaderDuplicates(action, payload, nameBlock->sourceMap, parser.sourceData, result.first);
-            
-            return result;
         }
-        
-        
+
         /**
          *  \brief  Check & report payload validity.
-         *  \param  section     A section of the payload.
+         *  \param  sectionType A section of the payload.
          *  \param  sourceMap   Payload signature source map.
          *  \param  payload     The payload to be checked.
+         *  \param  action      The Action to which payload belongs to.
+         *  \param  report      Parser report.
          */
-        static void CheckPayload(const SectionType& section,
+        static void checkPayload(SectionType sectionType,
+                                 const mdp::CharactersRangeSet sourceMap,
                                  const Payload& payload,
-                                 const HTTPMethod method,
-                                 const SourceDataBlock& sourceMap,
-                                 const SourceData& sourceData,
-                                 Result& result) {
-            
-            bool warnEmptyBody = false;
-
-            std::string contentLength;
-            std::string transferEncoding;
+                                 const Action& action,
+                                 Report& report) {
 
-            for (Collection<Header>::const_iterator it = payload.headers.begin();
-                 it != payload.headers.end();
-                 ++it) {
+            if (isPayloadDuplicate(sectionType, payload, action.examples.back())) {
 
-                if (it->first == HTTPHeaderName::ContentLength) {
-                    contentLength = it->second;
-                }
+                // WARN: Duplicate payload
+                std::stringstream ss;
+                ss << SectionName(sectionType) << " payload `" << payload.name << "`";
+                ss << " already defined for `" << action.method << "` method";
 
-                if (it->first == HTTPHeaderName::TransferEncoding) {
-                    transferEncoding = it->second;
-                }
+                report.warnings.push_back(Warning(ss.str(),
+                                                  DuplicateWarning,
+                                                  sourceMap));
             }
-            
-            if (section == RequestSectionType) {
-                
-                if (payload.body.empty()) {
-                    
-                    // Warn when content-length or transfer-encoding is specified or both headers and body are empty
-                    if (payload.headers.empty()) {
-                        warnEmptyBody = true;
-                    }
-                    else {
-                        warnEmptyBody = !contentLength.empty() ||
-                                        !transferEncoding.empty();
-                    }
 
-                    if (warnEmptyBody) {
-                        // WARN: empty body
-                        std::stringstream ss;
-                        ss << "empty " << SectionName(section) << " " << SectionName(BodySectionType);
+            if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
 
-                        if (!contentLength.empty()) {
-                            ss << ", expected " << SectionName(BodySectionType) << " for '" << contentLength << "' Content-Length";
-                        }
-                        else if (!transferEncoding.empty()) {
-                            ss << ", expected " << SectionName(BodySectionType) << " for '" << transferEncoding << "' Transfer-Encoding";
-                        }
-
-                        result.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          MapSourceDataBlock(sourceMap, sourceData)));
-                    }
-
-                }
-            }
-            else if (section == ResponseSectionType) {
-                // Check status code
-                HTTPStatusCode code = 0;
+                HTTPStatusCode code;
 
                 if (!payload.name.empty()) {
                     std::stringstream(payload.name) >> code;
                 }
 
-                StatusCodeTraits statusCodeTraits = GetStatusCodeTrait(code);
-                HTTPMethodTraits methodTraits = GetMethodTrait(method);
-
-                if ((!statusCodeTraits.allowBody || !methodTraits.allowBody) && !payload.body.empty()) {
-                    // WARN: not empty body
+                HTTPMethodTraits methodTraits = GetMethodTrait(action.method);
 
-                    if (!statusCodeTraits.allowBody) {
-                        std::stringstream ss;
-                        ss << "the " << code << " response MUST NOT include a " << SectionName(BodySectionType);
-                        result.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          MapSourceDataBlock(sourceMap, sourceData)));
-                    }
+                if (!methodTraits.allowBody && !payload.body.empty()) {
 
                     // WARN: Edge case for 2xx CONNECT
-                    if (method == HTTPMethodName::Connect && code/100 == 2) {
+                    if (action.method == HTTPMethodName::Connect && code/100 == 2) {
+
                         std::stringstream ss;
-                        ss << "the response for " << code << " " << method << " request MUST NOT include a " << SectionName(BodySectionType);
-                        result.warnings.push_back(Warning(ss.str(),
+                        ss << "the response for " << code << " " << action.method << " request MUST NOT include a " << SectionName(BodySectionType);
+
+                        report.warnings.push_back(Warning(ss.str(),
                                                           EmptyDefinitionWarning,
-                                                          MapSourceDataBlock(sourceMap, sourceData)));
+                                                          sourceMap));
+                    } else if (action.method != HTTPMethodName::Connect && !methodTraits.allowBody) {
 
-                    }
-                    else if (method != HTTPMethodName::Connect && !methodTraits.allowBody) {
                         std::stringstream ss;
-                        ss << "the response for " << method << " request MUST NOT include a " << SectionName(BodySectionType);
-                        result.warnings.push_back(Warning(ss.str(),
+                        ss << "the response for " << action.method << " request MUST NOT include a " << SectionName(BodySectionType);
+
+                        report.warnings.push_back(Warning(ss.str(),
                                                           EmptyDefinitionWarning,
-                                                          MapSourceDataBlock(sourceMap, sourceData)));
+                                                          sourceMap));
                     }
 
                     return;
@@ -482,22 +345,95 @@ namespace snowcrash {
          *  Checks whether given section payload has duplicate within its transaction examples
          *  \return True when a duplicate is found, false otherwise.
          */
-        static bool IsPayloadDuplicate(const SectionType& section, const Payload& payload, TransactionExample& example) {
-            
-            if (section == RequestSectionType) {
+        static bool isPayloadDuplicate(SectionType& sectionType,
+                                       const Payload& payload,
+                                       const TransactionExample& example) {
+
+            if (sectionType == RequestSectionType) {
+
                 Collection<Request>::const_iterator duplicate = FindRequest(example, payload);
                 return duplicate != example.requests.end();
-            }
-            else if (section == ResponseSectionType) {
+            } else if (sectionType == ResponseSectionType) {
+
                 Collection<Response>::const_iterator duplicate = FindResponse(example, payload);
                 return duplicate != example.responses.end();
             }
 
             return false;
         }
+
+        /** Warn about deprecated headers */
+        static MarkdownNodeIterator handleDeprecatedHeaders(const MarkdownNodeIterator& node,
+                                                            const MarkdownNodes& siblings,
+                                                            SectionParserData& pd,
+                                                            Report& report,
+                                                            Headers& headers) {
+
+            MarkdownNodeIterator cur = HeadersParser::parse(node, siblings, pd, report, headers);
+
+            // WARN: Deprecated header sections
+            std::stringstream ss;
+            ss << "the 'headers' section at this level is deprecated and will be removed in a future, use respective payload header section(s) instead";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.warnings.push_back(Warning(ss.str(),
+                                              DeprecatedWarning,
+                                              sourceMap));
+
+            return cur;
+        }
+        
+        /** \return %ActionType of a node */
+        static ActionType actionType(const MarkdownNodeIterator& node) {
+            
+            if (node->type != mdp::HeaderMarkdownNodeType || node->text.empty())
+                return NotActionType;
+                
+            mdp::ByteBuffer subject = node->text;
+            TrimString(subject);
+            
+            if (RegexMatch(subject, NamedActionHeaderRegex)) {
+                return DependentActionType;
+            }
+            
+            CaptureGroups captureGroups;
+            if (RegexCapture(subject, ActionHeaderRegex, captureGroups, 3)) {
+                
+                if (captureGroups[2].empty()) {
+                    return DependentActionType;
+                }
+                else {
+                    return CompleteActionType;
+                }
+            }
+            
+            return NotActionType;
+        }
+
+        /** \return HTTP request method and name of an action */
+        static void actionHTTPMethodAndName(const MarkdownNodeIterator& node,
+                                            mdp::ByteBuffer& method,
+                                            mdp::ByteBuffer& name) {
+            
+            CaptureGroups captureGroups;
+            mdp::ByteBuffer subject, remaining;
+            
+            subject = GetFirstLine(node->text, remaining);
+            TrimString(subject);
+            
+            if (RegexCapture(subject, ActionHeaderRegex, captureGroups, 3)) {
+                method = captureGroups[1];
+            } else if (RegexCapture(subject, NamedActionHeaderRegex, captureGroups, 3)) {
+                name = captureGroups[1];
+                method = captureGroups[2];
+            }
+            
+            return;
+        }
     };
-    
-    typedef BlockParser<Action, SectionParser<Action> > ActionParser;
+
+    /** Action Section Parser */
+    typedef SectionParser<Action, HeaderSectionAdapter> ActionParser;
 }
 
 #endif