redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/Platform.h

@@ -17,17 +17,14 @@
 #endif
 
 #if defined(_MSC_VER)
-#   define FORCEINLINE __forceinline
 #   if !defined(DEPRECATED)
 #       define DEPRECATED __declspec(deprecated)
 #   endif
 #elif defined(__clang__) || defined(__GNUC__)
-#   define FORCEINLINE inline
 #   if !defined(DEPRECATED)
 #       define DEPRECATED __attribute__((deprecated))
 #   endif
 #else
-#   define FORCEINLINE inline
 #   if !defined(DEPRECATED)
 #       define DEPRECATED
 #   endif

data/ext/snowcrash/src/ResourceGroupParser.h

@@ -9,187 +9,206 @@
 #ifndef SNOWCRASH_RESOURCEGROUPPARSER_H
 #define SNOWCRASH_RESOURCEGROUPPARSER_H
 
-#include "BlueprintParserCore.h"
-#include "Blueprint.h"
+#include "SectionParser.h"
 #include "ResourceParser.h"
+#include "RegexMatch.h"
+
+namespace snowcrash {
 
-namespace snowcrashconst {
-    
     const char* const GroupHeaderRegex = "^[[:blank:]]*[Gg]roup[[:blank:]]+" SYMBOL_IDENTIFIER "[[:blank:]]*$";
-}
 
-namespace snowcrash {
-    
-    /**
-     *  \brief Find a group in the blueprint by the group name.
-     *  \param blueprint A blueprint AST to be searched.
-     *  \param group A resource group to look for.
-     *  \returns An iterator at matching group within blueprint's resource groups collection.
-     */
-    FORCEINLINE Collection<ResourceGroup>::const_iterator FindResourceGroup(const Blueprint& blueprint,
-                                                                            const ResourceGroup& group) {
-
-        return std::find_if(blueprint.resourceGroups.begin(),
-                            blueprint.resourceGroups.end(),
-                            std::bind2nd(MatchName<ResourceGroup>(), group));
-    }
-    
-    /**
-     *  \brief Check a markdown block of Group signature, also retrieves a group name.
-     *  \param block A markdown block to query for its signature and retrieve a group name from.
-     *  \param name An output buffer to retrieve a Resource Group Name into.
-     *  \returns True if the given markdown block has Resource group signature, false otherwise.
-     */
-    FORCEINLINE bool GetResourceGroupSignature(const MarkdownBlock& block,
-                                               Name& name) {
-        if (block.type != HeaderBlockType ||
-            block.content.empty())
-            return false;
-        
-        CaptureGroups captureGroups;
-        if (RegexCapture(block.content, snowcrashconst::GroupHeaderRegex, captureGroups, 3)) {
-            name = captureGroups[1];
-            return true;
-        }
-        
-        return false;
-    }
-    
+    /** Resource iterator pair: its containment group and resource iterator itself */
+    typedef std::pair<Collection<ResourceGroup>::const_iterator, ResourceIterator> ResourceIteratorPair;
+
+    /** Internal type alias for Collection of Resource */
+    typedef Collection<ResourceGroup>::type ResourceGroups;
+
+    typedef Collection<ResourceGroup>::const_iterator ResourceGroupIterator;
+
     /**
-     *  \brief Query whether given block has resource group signature.
-     *  \param block A markdown block to query its signature
-     *  \returns True if the given markdown block has Resource group signature, false otherwise.
+     * ResourceGroup Section processor
      */
-    FORCEINLINE bool HasResourceGroupSignature(const MarkdownBlock& block)
-    {
-        Name name;
-        return GetResourceGroupSignature(block, name);
-    }
-    
-    /** Internal list items classifier, Resource Group Context */
-    template <>
-    FORCEINLINE SectionType ClassifyInternaListBlock<ResourceGroup>(const BlockIterator& begin,
-                                                                    const BlockIterator& end) {
-        return UndefinedSectionType;
-    }
-    
-    /** Block Classifier, Resource Group Context */
-    template <>
-    FORCEINLINE SectionType ClassifyBlock<ResourceGroup>(const BlockIterator& begin,
-                                                         const BlockIterator& end,
-                                                         const SectionType& context) {
-        
-        if (HasResourceGroupSignature(*begin))
-            return (context == UndefinedSectionType) ? ResourceGroupSectionType : UndefinedSectionType;
-        
-        if (HasResourceSignature(*begin))
-            return ResourceSectionType;
-
-        return (context == ResourceGroupSectionType) ? context : UndefinedSectionType;
-    }
-    
-    /** Resource Group SectionType Parser */
     template<>
-    struct SectionParser<ResourceGroup> {
-        
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               ResourceGroup& group) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            switch (section.type) {
-                    
-                case ResourceGroupSectionType:
-                    result = HandleResourceGroupOverviewBlock(section, cur, parser, group);
-                    break;
-                    
-                case ResourceSectionType:
-                    result = HandleResource(section, cur, parser, group);
-                    break;
-                    
-                case UndefinedSectionType:
-                    break;
-                    
-                default:
-                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
-                    break;
+    struct SectionProcessor<ResourceGroup> : public SectionProcessorBase<ResourceGroup> {
+
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     Report& report,
+                                                     ResourceGroup& out) {
+
+            MarkdownNodeIterator cur = node;
+            SectionType nestedType = nestedSectionType(cur);
+
+            // Resources only, parse as exclusive nested sections
+            if (nestedType != UndefinedSectionType) {
+                layout = ExclusiveNestedSectionLayout;
+                return cur;
+            }
+
+            CaptureGroups captureGroups;
+
+            if (RegexCapture(node->text, GroupHeaderRegex, captureGroups, 3)) {
+                out.name = captureGroups[1];
+                TrimString(out.name);
             }
-            
-            return result;
+
+            return ++MarkdownNodeIterator(node);
         }
 
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             ResourceGroup& group,
-                             Result& result) {}
-
-        static ParseSectionResult HandleResourceGroupOverviewBlock(const BlueprintSection& section,
-                                                                   const BlockIterator& cur,
-                                                                   BlueprintParserCore& parser,
-                                                                   ResourceGroup& group) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            BlockIterator sectionCur(cur);
-
-            // Group Name
-            if (sectionCur == section.bounds.first) {
-                
-                GetResourceGroupSignature(*cur, group.name);
-                result.second = ++sectionCur;
-                return result;
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         Report& report,
+                                                         ResourceGroup& out) {
+
+            if (pd.sectionContext() == ResourceSectionType) {
+
+                Resource resource;
+                MarkdownNodeIterator cur = ResourceParser::parse(node, siblings, pd, report, resource);
+
+                ResourceIterator duplicate = findResource(out.resources, resource);
+                ResourceIteratorPair globalDuplicate;
+
+                if (duplicate == out.resources.end()) {
+                    globalDuplicate = findResource(pd.blueprint, resource);
+                }
+
+                if (duplicate != out.resources.end() ||
+                    globalDuplicate.first != pd.blueprint.resourceGroups.end()) {
+
+                    // WARN: Duplicate resource
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.warnings.push_back(Warning("the resource '" + resource.uriTemplate + "' is already defined",
+                                                      DuplicateWarning,
+                                                      sourceMap));
+                }
+
+                out.resources.push_back(resource);
+
+                return cur;
             }
-            
-            // Group Description
-            result = ParseDescriptionBlock<ResourceGroup>(section,
-                                                           sectionCur,
-                                                           parser.sourceData,
-                                                           group);
-            return result;
-            
+
+            return node;
         }
-        
-        static ParseSectionResult HandleResource(const BlueprintSection& section,
-                                                 const BlockIterator& cur,
-                                                 BlueprintParserCore& parser,
-                                                 ResourceGroup& group)
-        {
-            Resource resource;
-            ParseSectionResult result = ResourceParser::Parse(cur,
-                                                              section.bounds.second,
-                                                              section,
-                                                              parser,
-                                                              resource);
-            if (result.first.error.code != Error::OK)
-                return result;
-            
-            ResourceIterator duplicate = FindResource(group, resource);
-            ResourceIteratorPair globalDuplicate;
-            if (duplicate == group.resources.end())
-                globalDuplicate = FindResource(parser.blueprint, resource);
-
-         
-            
-            if (duplicate != group.resources.end() ||
-                globalDuplicate.first != parser.blueprint.resourceGroups.end()) {
-                
-                // WARN: Duplicate resource
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning("the resource '" +
-                                                        resource.uriTemplate +
-                                                        "' is already defined",
-                                                        DuplicateWarning,
-                                                        sourceBlock));
+
+        static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
+                                                          const MarkdownNodes& siblings,
+                                                          SectionParserData& pd,
+                                                          SectionType& lastSectionType,
+                                                          Report& report,
+                                                          ResourceGroup& out) {
+
+            if (SectionProcessor<Action>::actionType(node) == DependentActionType &&
+                !out.resources.empty()) {
+
+                mdp::ByteBuffer method;
+                mdp::ByteBuffer name;
+
+                SectionProcessor<Action>::actionHTTPMethodAndName(node, method, name);
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+
+                // WARN: Unexpected action
+                std::stringstream ss;
+                ss << "unexpected action '" << method << "', to define multiple actions for the '" << out.resources.back().uriTemplate;
+                ss << "' resource omit the HTTP method in its definition, e.g. '# /resource'";
+
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IgnoringWarning,
+                                                  sourceMap));
+
+                return ++MarkdownNodeIterator(node);
             }
 
+            return SectionProcessorBase<ResourceGroup>::processUnexpectedNode(node, siblings, pd, lastSectionType, report, out);
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::HeaderMarkdownNodeType
+                && !node->text.empty()) {
+
+                mdp::ByteBuffer subject = node->text;
+                TrimString(subject);
+
+                if (RegexMatch(subject, GroupHeaderRegex)) {
+                    return ResourceGroupSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            // Return ResourceSectionType or UndefinedSectionType
+            return SectionProcessor<Resource>::sectionType(node);
+        }
+
+        static SectionTypes nestedSectionTypes() {
+            SectionTypes nested;
+
+            // Resource & descendants
+            nested.push_back(ResourceSectionType);
+            SectionTypes types = SectionProcessor<Resource>::nestedSectionTypes();
+            nested.insert(nested.end(), types.begin(), types.end());
+
+            return nested;
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            mdp::ByteBuffer method;
 
-            
-            group.resources.push_back(resource); // FIXME: C++11 move
-            return result;
+            if (SectionProcessor<Action>::actionType(node) == CompleteActionType) {
+                return false;
+            }
+
+            return SectionProcessorBase<ResourceGroup>::isDescriptionNode(node, sectionType);
+        }
+
+        static bool isUnexpectedNode(const MarkdownNodeIterator& node,
+                                     SectionType sectionType) {
+
+            if (SectionProcessor<Action>::actionType(node) == DependentActionType) {
+                return true;
+            }
+
+            return SectionProcessorBase<ResourceGroup>::isUnexpectedNode(node, sectionType);
+        }
+
+        /** Finds a resource inside an resources collection */
+        static ResourceIterator findResource(const Resources& resources,
+                                             const Resource& resource) {
+
+            return std::find_if(resources.begin(),
+                                resources.end(),
+                                std::bind2nd(MatchResource(), resource));
+        }
+
+        /** Finds a resource in blueprint by its URI template */
+        static ResourceIteratorPair findResource(const Blueprint& blueprint,
+                                                 const Resource& resource) {
+
+            for (Collection<ResourceGroup>::const_iterator it = blueprint.resourceGroups.begin();
+                  it != blueprint.resourceGroups.end();
+                  ++it) {
+
+                ResourceIterator match = findResource(it->resources, resource);
+
+                if (match != it->resources.end()) {
+                    return std::make_pair(it, match);
+                }
+             }
+
+             return std::make_pair(blueprint.resourceGroups.end(), ResourceIterator());
         }
     };
-    
-    typedef BlockParser<ResourceGroup, SectionParser<ResourceGroup> > ResourceGroupParser;
+
+    /** ResourceGroup Section Parser */
+    typedef SectionParser<ResourceGroup, HeaderSectionAdapter> ResourceGroupParser;
 }
 
 #endif

data/ext/snowcrash/src/ResourceParser.h

@@ -9,576 +9,408 @@
 #ifndef SNOWCRASH_RESOURCEPARSER_H
 #define SNOWCRASH_RESOURCEPARSER_H
 
-#include <sstream>
-#include "BlueprintParserCore.h"
-#include "Blueprint.h"
+#include "SectionParser.h"
 #include "ActionParser.h"
-#include "RegexMatch.h"
-#include "StringUtility.h"
+#include "HeadersParser.h"
 #include "ParametersParser.h"
-#include "DescriptionSectionUtility.h"
 #include "UriTemplateParser.h"
+#include "RegexMatch.h"
 
-namespace snowcrashconst {
+namespace snowcrash {
     
     /** Nameless resource matching regex */
     const char* const ResourceHeaderRegex = "^[[:blank:]]*(" HTTP_REQUEST_METHOD "[[:blank:]]+)?" URI_TEMPLATE "$";
     
     /** Named resource matching regex */
     const char* const NamedResourceHeaderRegex = "^[[:blank:]]*" SYMBOL_IDENTIFIER "[[:blank:]]+\\[" URI_TEMPLATE "]$";
-}
 
-namespace snowcrash {
-    
-    // Resource signature
-    enum ResourceSignature {
-        UndefinedResourceSignature,
-        NoResourceSignature,
-        URIResourceSignature,
-        MethodURIResourceSignature,
-        NamedResourceSignature
-    };
-    
-    // Query resource signature
-    FORCEINLINE ResourceSignature GetResourceSignature(const MarkdownBlock& block,
-                                                       Name& name,
-                                                       URITemplate& uri,
-                                                       HTTPMethod& method) {
-        if (block.type != HeaderBlockType ||
-            block.content.empty())
-            return NoResourceSignature;
-        
-        CaptureGroups captureGroups;
-        // Nameless resource
-        if (RegexCapture(block.content, snowcrashconst::ResourceHeaderRegex, captureGroups, 4)) {
-            method = captureGroups[2];
-            uri = captureGroups[3];
-            return (method.empty()) ? URIResourceSignature : MethodURIResourceSignature;
-        }
-        else if (RegexCapture(block.content, snowcrashconst::NamedResourceHeaderRegex, captureGroups, 4)) {
-            method.clear();
-            name = captureGroups[1];
-            TrimString(name);
-            uri = captureGroups[2];
-            return NamedResourceSignature;
-        }
+    /** Internal type alias for Collection of Resource */
+    typedef Collection<Resource>::type Resources;
 
-        return NoResourceSignature;
-    }
-    
-    // Returns true if block has resource header signature, false otherwise
-    FORCEINLINE bool HasResourceSignature(const MarkdownBlock& block) {
+    typedef Collection<Resource>::const_iterator ResourceIterator;
 
-        Name name;
-        URITemplate uri;
-        HTTPMethod method;
-        return GetResourceSignature(block, name, uri, method) != NoResourceSignature;
-    }
+    /**
+     * Resource Section processor
+     */
+    template<>
+    struct SectionProcessor<Resource> : public SectionProcessorBase<Resource> {
 
-    // Resource iterator in its containment group
-    typedef Collection<Resource>::const_iterator ResourceIterator;
-    
-    // Finds a resource in resource group by its URI template
-    FORCEINLINE ResourceIterator FindResource(const ResourceGroup& group,
-                                              const Resource& resource) {
-        return std::find_if(group.resources.begin(),
-                            group.resources.end(),
-                            std::bind2nd(MatchResource(), resource));
-    }
-
-    // Resource iterator pair: its containment group and resource iterator itself
-    typedef std::pair<Collection<ResourceGroup>::const_iterator, ResourceIterator> ResourceIteratorPair;
-    
-    // Finds a resource in blueprint by its URI template
-    FORCEINLINE ResourceIteratorPair FindResource(const Blueprint& blueprint,
-                                                  const Resource& resource) {
-        
-        for (Collection<ResourceGroup>::const_iterator it = blueprint.resourceGroups.begin();
-             it != blueprint.resourceGroups.end();
-             ++it) {
-            
-            Collection<Resource>::const_iterator match = FindResource(*it, resource);
-            if (match != it->resources.end())
-                return std::make_pair(it, match);
-        }
-        
-        return std::make_pair(blueprint.resourceGroups.end(), Collection<Resource>::iterator());
-    }
-    
-    
-    //
-    // Classifier of internal list items, Resource context
-    //
-    template <>
-    FORCEINLINE SectionType ClassifyInternaListBlock<Resource>(const BlockIterator& begin,
-                                                           const BlockIterator& end) {
-        if (HasHeaderSignature(begin, end))
-            return HeadersSectionType;
-        
-        if (HasParametersSignature(begin, end))
-            return ParametersSectionType;
-        
-        Name name;
-        SourceData mediaType;
-        PayloadSignature payloadSignature = GetPayloadSignature(begin, end, name, mediaType);
-        if (payloadSignature == ObjectPayloadSignature)
-            return ObjectSectionType;
-        else if (payloadSignature == ModelPayloadSignature)
-            return ModelSectionType;
-
-        return UndefinedSectionType;
-    }
-    
-    /** Children blocks classifier */
-    template <>
-    FORCEINLINE SectionType ClassifyChildrenListBlock<Resource>(const BlockIterator& begin,
-                                                              const BlockIterator& end) {
-        
-        SectionType type = ClassifyInternaListBlock<Resource>(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;
-        
-        type = ClassifyChildrenListBlock<Payload>(begin, end);
-        if (type != UndefinedSectionType)
-            return type;
-        
-        return UndefinedSectionType;
-    }
-    
-    //
-    // Block Classifier, Resource Context
-    //
-    template <>
-    FORCEINLINE SectionType ClassifyBlock<Resource>(const BlockIterator& begin,
-                                                const BlockIterator& end,
-                                                const SectionType& context) {
-        if (HasResourceGroupSignature(*begin))
-            return UndefinedSectionType;
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     Report& report,
+                                                     Resource& out) {
+
+            CaptureGroups captureGroups;
+
+            // If Abbreviated resource section
+            if (RegexCapture(node->text, ResourceHeaderRegex, captureGroups, 4)) {
+
+                out.uriTemplate = captureGroups[3];
+
+                // Make this section an action
+                if (!captureGroups[2].empty()) {
 
-        Name name;
-        URITemplate uri;
-        HTTPMethod method;
-        ResourceSignature resourceSignature = GetResourceSignature(*begin, name, uri, method);
-        if (resourceSignature != NoResourceSignature) {
-            return (context == UndefinedSectionType) ?
-                    ((resourceSignature == MethodURIResourceSignature) ? ResourceMethodSectionType : ResourceSectionType) :
-                    UndefinedSectionType;
+                    Action action;
+                    MarkdownNodeIterator cur = ActionParser::parse(node, node->parent().children(), pd, report, action);
+
+                    out.actions.push_back(action);
+                    layout = RedirectSectionLayout;
+
+                    return cur;
+                }
+            } else if (RegexCapture(node->text, NamedResourceHeaderRegex, captureGroups, 4)) {
+
+                out.name = captureGroups[1];
+                TrimString(out.name);
+                out.uriTemplate = captureGroups[2];
+            }
+
+            return ++MarkdownNodeIterator(node);
         }
-        
-        if (HasActionSignature(*begin))
-            return (context != ResourceMethodSectionType) ? ActionSectionType : UndefinedSectionType;
-        
-        SectionType listSection = ClassifyInternaListBlock<Resource>(begin, end);
-        if (listSection != UndefinedSectionType)
-            return listSection;
-        
-        // Unrecognized list item at this level
-        if (begin->type == ListItemBlockBeginType)
-            return ForeignSectionType;
-        
-        return (context == ResourceSectionType) ? context : UndefinedSectionType;
-    }
-        
-    //
-    // Resource SectionType Parser
-    //
-    template<>
-    struct SectionParser<Resource> {
-        
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               Resource& resource) {
-            ParseSectionResult result = std::make_pair(Result(), cur);
-           
-            switch (section.type) {
-                case ResourceSectionType:
-                    result = HandleResourceDescriptionBlock(section, cur, parser, resource);
-                    break;
-                    
-                case ResourceMethodSectionType:
-                    result = HandleResourceMethod(section, cur, parser, resource);
-                    break;
-                
-                case ModelSectionType:
-                case ObjectSectionType:
-                    result = HandleModel(section, cur, parser, resource);
-                    break;
-                    
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         Report& report,
+                                                         Resource& out) {
+
+            switch (pd.sectionContext()) {
+                case ActionSectionType:
+                    return processAction(node, siblings, pd, report, out);
+
                 case ParametersSectionType:
-                    result = HandleParameters(section, cur, parser, resource);
-                    break;
-                    
+                    return processParameters(node, siblings, pd, report, out);
+
+                case ModelSectionType:
+                case ModelBodySectionType:
+                    return processModel(node, siblings, pd, report, out);
+
                 case HeadersSectionType:
-                    result = HandleDeprecatedHeaders(section, cur, parser, resource);
-                    break;
-                    
-                case ActionSectionType:
-                    result = HandleAction(section, cur, parser, resource);
-                    break;
-                    
-                case UndefinedSectionType:
-                    CheckAmbiguousMethod(section, cur, resource, parser.sourceData, result.first);
-                    result.second = CloseList(cur, section.bounds.second);
-                    break;
-                    
-                case ForeignSectionType:
-                    result = HandleForeignSection<Resource>(section, cur, parser.sourceData);
-                    break;
-                    
+                    return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, report, out.headers);
+
                 default:
-                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
                     break;
             }
 
+            return node;
+        }
+        
+        static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
+                                                          const MarkdownNodes& siblings,
+                                                          SectionParserData& pd,
+                                                          SectionType& sectionType,
+                                                          Report& report,
+                                                          Resource& out) {
             
-            return result;
+            if ((node->type == mdp::ParagraphMarkdownNodeType ||
+                 node->type == mdp::CodeMarkdownNodeType) &&
+                (sectionType == ModelBodySectionType ||
+                 sectionType == ModelSectionType)) {
+                
+                CodeBlockUtility::addDanglingAsset(node, pd, sectionType, report, out.model.body);
+
+                // Update model in the symbol table as well
+                ResourceModelSymbolTable::iterator it = pd.symbolTable.resourceModels.find(out.model.name);
+                
+                if (it != pd.symbolTable.resourceModels.end()) {
+                    it->second.body = out.model.body;
+                }
+                
+                return ++MarkdownNodeIterator(node);
+            }
+            
+            return SectionProcessorBase<Resource>::processUnexpectedNode(node, siblings, pd, sectionType, report, out);
         }
         
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             Resource& resource,
-                             Result& result)
-        {
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+            
+            if (SectionProcessor<Action>::actionType(node) == CompleteActionType) {
+                return false;
+            }
+                
+            return SectionProcessorBase<Resource>::isDescriptionNode(node, sectionType);
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::HeaderMarkdownNodeType
+                && !node->text.empty()) {
+
+                CaptureGroups captureGroups;
+                mdp::ByteBuffer subject = node->text;
+
+                TrimString(subject);
+
+                if (RegexMatch(subject, NamedResourceHeaderRegex) ||
+                    RegexMatch(subject, ResourceHeaderRegex)) {
+                    return ResourceSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            SectionType nestedType = UndefinedSectionType;
+
+            // Check if parameters section
+            nestedType = SectionProcessor<Parameters>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            // Check if headers section
+            nestedType = SectionProcessor<Headers>::sectionType(node);
+
+            if (nestedType == HeadersSectionType) {
+                return nestedType;
+            }
+
+            // Check if model section
+            nestedType = SectionProcessor<Payload>::sectionType(node);
+
+            if (nestedType == ModelSectionType ||
+                nestedType == ModelBodySectionType) {
+
+                return nestedType;
+            }
+
+            // Check if action section
+            nestedType = SectionProcessor<Action>::sectionType(node);
+
+            if (nestedType == ActionSectionType) {
+                
+                // Do not consider complete actions as nested
+                mdp::ByteBuffer method;
+                if (SectionProcessor<Action>::actionType(node) == CompleteActionType)
+                    return UndefinedSectionType;
+                
+                return nestedType;
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionTypes nestedSectionTypes() {
+            SectionTypes nested;
+
+            // Action & descendants
+            nested.push_back(ActionSectionType);
+            SectionTypes types = SectionProcessor<Action>::nestedSectionTypes();
+            nested.insert(nested.end(), types.begin(), types.end());
+
+            nested.push_back(ModelSectionType);
+            nested.push_back(ModelBodySectionType);
+
+            return nested;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             Report& report,
+                             Resource& out) {
+
+            if (!out.uriTemplate.empty()) {
 
-            if (!resource.uriTemplate.empty()) {
                 URITemplateParser uriTemplateParser;
                 ParsedURITemplate parsedResult;
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(bounds.first, bounds.first, bounds, parser.sourceData);
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+
+                uriTemplateParser.parse(out.uriTemplate, sourceMap, parsedResult);
 
-                uriTemplateParser.parse(resource.uriTemplate, sourceBlock, parsedResult);
-                if (parsedResult.result.warnings.size() > 0) {
-                    result += parsedResult.result;
+                if (!parsedResult.report.warnings.empty()) {
+                    report += parsedResult.report;
                 }
             }
 
             // Consolidate depraceted headers into subsequent payloads
-            if (!resource.headers.empty()) {
-                for (Collection<Action>::iterator it = resource.actions.begin();
-                     it != resource.actions.end();
+            if (!out.headers.empty()) {
+
+                for (Collection<Action>::iterator it = out.actions.begin();
+                     it != out.actions.end();
                      ++it) {
-                  InjectDeprecatedHeaders(resource.headers, it->examples);
+
+                    SectionProcessor<Headers>::injectDeprecatedHeaders(out.headers, it->examples);
                 }
-                
-                resource.headers.clear();
+
+                out.headers.clear();
             }
+        }
+
+        /** Process Action section */
+        static MarkdownNodeIterator processAction(const MarkdownNodeIterator& node,
+                                                  const MarkdownNodes& siblings,
+                                                  SectionParserData& pd,
+                                                  Report& report,
+                                                  Resource& out) {
+
+            Action action;
+            MarkdownNodeIterator cur = ActionParser::parse(node, siblings, pd, report, action);
 
+            ActionIterator duplicate = findAction(out.actions, action);
+
+            if (duplicate != out.actions.end()) {
+
+                // WARN: duplicate method
+                std::stringstream ss;
+                ss << "action with method '" << action.method << "' already defined for resource '";
+                ss << out.uriTemplate << "'";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  DuplicateWarning,
+                                                  sourceMap));
+            }
+
+            if (!action.parameters.empty()) {
+
+                checkParametersEligibility(node, pd, out, action.parameters, report);
+            }
+
+            out.actions.push_back(action);
+
+            return cur;
         }
-        
-        static ParseSectionResult HandleResourceDescriptionBlock(const BlueprintSection& section,
-                                                                 const BlockIterator& cur,
-                                                                 BlueprintParserCore& parser,
-                                                                 Resource& resource) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            BlockIterator sectionCur(cur);            
-            
-            // Retrieve URI            
-            if (cur->type == HeaderBlockType &&
-                cur == section.bounds.first) {
-                
-                HTTPMethod method;
-                GetResourceSignature(*cur, resource.name, resource.uriTemplate, method);
-                result.second = ++sectionCur;
-                return result;
+
+        /** Process Parameters section */
+        static MarkdownNodeIterator processParameters(const MarkdownNodeIterator& node,
+                                                      const MarkdownNodes& siblings,
+                                                      SectionParserData& pd,
+                                                      Report& report,
+                                                      Resource& out) {
+
+            Parameters parameters;
+            MarkdownNodeIterator cur = ParametersParser::parse(node, siblings, pd, report, parameters);
+
+            if (!parameters.empty()) {
+
+                checkParametersEligibility(node, pd, out, parameters, report);
+                out.parameters.insert(out.parameters.end(), parameters.begin(), parameters.end());
             }
 
-            result = ParseDescriptionBlock<Resource>(section,
-                                                      sectionCur,
-                                                      parser.sourceData,
-                                                      resource);
-            return result;
+            return cur;
         }
-        
-        static ParseSectionResult HandleModel(const BlueprintSection& section,
-                                              const BlockIterator& cur,
-                                              BlueprintParserCore& parser,
-                                              Resource& resource)
-        {
-            Payload payload;
-            ParseSectionResult result = PayloadParser::Parse(cur,
-                                                             section.bounds.second,
-                                                             section,
-                                                             parser,
-                                                             payload);
-            if (result.first.error.code != Error::OK)
-                return result;
-            
-            // Check whether there isnt a model already
-            if (!resource.model.name.empty()) {
+
+        /** Process Model section */
+        static MarkdownNodeIterator processModel(const MarkdownNodeIterator& node,
+                                                 const MarkdownNodes& siblings,
+                                                 SectionParserData& pd,
+                                                 Report& report,
+                                                 Resource& out) {
+
+            Payload model;
+            MarkdownNodeIterator cur = PayloadParser::parse(node, siblings, pd, report, model);
+
+            // Check whether there isn't a model already
+            if (!out.model.name.empty()) {
 
                 // WARN: Model already defined
                 std::stringstream ss;
-                ss << "overshadowing previous model definiton for '";
+                ss << "overshadowing previous model definition for '";
 
-                if (!resource.name.empty())
-                    ss << resource.name << "(" << resource.uriTemplate << ")";
-                else
-                    ss << resource.uriTemplate;
+                if (!out.name.empty()) {
+                    ss << out.name << "(" << out.uriTemplate << ")";
+                } else {
+                    ss << out.uriTemplate;
+                }
 
                 ss << "' resource, a resource can be represented by a single model only";
-                
-                BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(ss.str(),
-                                                        DuplicateWarning,
-                                                        sourceBlock));
-                
-                return result;
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  DuplicateWarning,
+                                                  sourceMap));
             }
 
-            // Check symbol name
-            if (payload.name.empty()) {
-                
-                if (!resource.name.empty()) {
-                    payload.name = resource.name;
-                }
-                else {
+            if (model.name.empty()) {
+
+                if (!out.name.empty()) {
+                    model.name = out.name;
+                } else {
+
                     // ERR: No name specified for resource model
                     std::stringstream ss;
                     ss << "resource model can be specified only for a named resource";
-                    ss << ", name your resource, e.g. '# <resource name> [" << resource.uriTemplate << "]'";
+                    ss << ", name your resource, e.g. '# <resource name> [" << out.uriTemplate << "]'";
 
-                    BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-                    SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
-                    result.first.error = Error(ss.str(),
-                                               SymbolError,
-                                               sourceBlock);
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.error = Error(ss.str(),
+                                         SymbolError,
+                                         sourceMap);
                 }
             }
-            
-            // Check whether symbol isn't already defined
-            ResourceModelSymbolTable::const_iterator it = parser.symbolTable.resourceModels.find(payload.name);
-            if (it == parser.symbolTable.resourceModels.end()) {
 
-                parser.symbolTable.resourceModels[payload.name] = payload;
-            }
-            else {
+            ResourceModelSymbolTable::iterator it = pd.symbolTable.resourceModels.find(model.name);
+
+            if (it == pd.symbolTable.resourceModels.end()) {
+
+                pd.symbolTable.resourceModels[model.name] = model;
+            } else {
+
                 // ERR: Symbol already defined
                 std::stringstream ss;
-                ss << "symbol '" << payload.name << "' already defined";
+                ss << "symbol '" << model.name << "' already defined";
 
-                BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
-                result.first.error = Error(ss.str(),
-                                           SymbolError,
-                                           sourceBlock);
-            }
-            
-            // Assign model
-            resource.model = payload;
-            
-            return result;
-        }
-        
-        /** Parse Parameters section */
-        static ParseSectionResult HandleParameters(const BlueprintSection& section,
-                                                   const BlockIterator& cur,
-                                                   BlueprintParserCore& parser,
-                                                   Resource& resource) {
-            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 {
-                // Check Eligibility
-                BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
-                CheckParametersEligibility(resource, parameters, nameBlock->sourceMap, parser.sourceData, result.first);
-                
-                // Insert
-                resource.parameters.insert(resource.parameters.end(), parameters.begin(), parameters.end());
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.error = Error(ss.str(),
+                                     SymbolError,
+                                     sourceMap);
             }
-            
-            return result;
+
+            out.model = model;
+
+            return cur;
         }
-        
-        /** Check parameter eligibility, reporting if a parameter is not specified in URI template */
-        static void CheckParametersEligibility(const Resource& resource,
-                                               const ParameterCollection& parameters,
-                                               const SourceDataBlock& location,
-                                               const SourceData& sourceData,
-                                               Result& result)
-        {
-            for (ParameterCollection::const_iterator it = parameters.begin();
+
+        /** Check Parameters eligibility in URI template */
+        static void checkParametersEligibility(const MarkdownNodeIterator& node,
+                                               const SectionParserData& pd,
+                                               Resource& resource,
+                                               Parameters& parameters,
+                                               Report& report) {
+
+            for (ParameterIterator it = parameters.begin();
                  it != parameters.end();
                  ++it) {
-                
+
                 // Naive check whether parameter is present in URI Template
                 if (resource.uriTemplate.find(it->name) == std::string::npos) {
+
                     // WARN: parameter name not present
                     std::stringstream ss;
                     ss << "parameter '" << it->name << "' not specified in ";
-                    if (!resource.name.empty())
+
+                    if (!resource.name.empty()) {
                         ss << "'" << resource.name << "' ";
+                    }
+
                     ss << "its '" << resource.uriTemplate << "' URI template";
 
-                    result.warnings.push_back(Warning(ss.str(),
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.warnings.push_back(Warning(ss.str(),
                                                       LogicalErrorWarning,
-                                                      MapSourceDataBlock(location, sourceData)));
+                                                      sourceMap));
                 }
             }
         }
-        
-        static ParseSectionResult HandleResourceMethod(const BlueprintSection& section,
-                                                       const BlockIterator& cur,
-                                                       BlueprintParserCore& parser,
-                                                       Resource& resource) {
-            
-            // Retrieve URI template
-            HTTPMethod method;
-            GetResourceSignature(*cur, resource.name, resource.uriTemplate, method);
-            
-            // Parse as a resource action abbreviation
-            return HandleAction(section, cur, parser, resource, true);
-        }
-        
-        static ParseSectionResult HandleAction(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               Resource& resource,
-                                               bool abbrev = false)
-        {
-            Action action;
-            ParseSectionResult result = ActionParser::Parse(cur,
-                                                            section.bounds.second,
-                                                            section,
-                                                            parser,
-                                                            action);
-            if (result.first.error.code != Error::OK)
-                return result;
-
-            if (!abbrev) {
-                Name name;
-                HTTPMethod httpMethod;
-                ActionSignature actionSignature = GetActionSignature(*cur, name, httpMethod);
-
-                if (actionSignature == MethodURIActionSignature) {
-                    // WARN: ignoring extraneous content in action header
-                    std::stringstream ss;
-                    ss << "ignoring additional content in method header '" << cur->content << "'";
-                    ss << ", expected method-only e.g. '# " << action.method << "'";
-                    
-                    SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, parser.sourceData);
-                    result.first.warnings.push_back(Warning(ss.str(),
-                                                            IgnoringWarning,
-                                                            sourceBlock));
-                }
-            }
-            
-            Collection<Action>::iterator duplicate = FindAction(resource, action);
-            if (duplicate != resource.actions.end()) {
-                
-                // WARN: duplicate method
-                std::stringstream ss;
-                ss << "action with method '" << action.method << "' already defined for resource '";
-                ss << resource.uriTemplate << "'";
-                
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(ss.str(),
-                                                        DuplicateWarning,
-                                                        sourceBlock));
-            }
-            
-            // Check Eligibility
-            if (!action.parameters.empty())
-                CheckParametersEligibility(resource, action.parameters, cur->sourceMap, parser.sourceData, result.first);
-            
-            
-            // Check for header duplictes
-            DeepCheckHeaderDuplicates(resource, action, cur->sourceMap, parser.sourceData, result.first);
-            
-            if (action.examples.empty() ||
-                action.examples.front().responses.empty()) {
-                // WARN: method has no response
-                std::stringstream ss;
-                ss << "no response defined for '" << action.method << " " << resource.uriTemplate << "'";
-                
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(ss.str(),
-                                                        EmptyDefinitionWarning,
-                                                        sourceBlock));
-            }
-            
-            resource.actions.push_back(action);
-            return result;
-        }
-        
-        static void DeepCheckHeaderDuplicates(const Resource& resource,
-                                              const Action& action,
-                                              const SourceDataBlock& sourceMap,
-                                              const SourceData& sourceData,
-                                              Result& result) {
-            
-            if (action.examples.empty())
-                return;
-            
-            CheckHeaderDuplicates(resource, action, sourceMap, sourceData, result);
-            for (Collection<Request>::const_iterator it = action.examples.front().requests.begin();
-                 it != action.examples.front().requests.end();
-                 ++it) {
-                
-                CheckHeaderDuplicates(resource, *it, sourceMap, sourceData, result);
-            }
-            for (Collection<Response>::const_iterator it = action.examples.front().responses.begin();
-                 it != action.examples.front().responses.end();
-                 ++it) {
-                
-                CheckHeaderDuplicates(resource, *it, sourceMap, sourceData, result);
-            }
-        }
-        
-        // Check whether abbreviated resource action isn't followed by an
-        // action header which would imply possible additional method intended.
-        static void CheckAmbiguousMethod(const BlueprintSection& section,
-                                         const BlockIterator& cur,
-                                         const Resource& resource,
-                                         const SourceData& sourceData,
-                                         Result& result) {
-            
-            if (cur == section.bounds.second ||
-                cur->type != HeaderBlockType)
-                return;
-            
-            Name name;
-            HTTPMethod method;
-            ActionSignature actionSignature = GetActionSignature(*cur, name, method);
-            if (actionSignature == MethodActionSignature ||
-                actionSignature == NamedActionSignature) {
-                // WARN: ignoring possible method header
-                std::stringstream ss;
-                ss << "unexpected action '" << cur->content << "', ";
-                ss << "to the define muliple actions for the '" << resource.uriTemplate << "' resource omit the HTTP method in its definition, ";
-                ss << "e.g. '# " << resource.uriTemplate << "'";
-                
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, sourceData);
-                result.warnings.push_back(Warning(ss.str(),
-                                                  IgnoringWarning,
-                                                  sourceBlock));
-            }
+
+        /** Finds an action inside an actions collection */
+        static ActionIterator findAction(const Actions& actions,
+                                         const Action& action) {
+
+            return std::find_if(actions.begin(),
+                                actions.end(),
+                                std::bind2nd(MatchAction<Action>(), action));
         }
     };
-    
-    typedef BlockParser<Resource, SectionParser<Resource> > ResourceParser;
+
+    /** Resource Section Parser */
+    typedef SectionParser<Resource, HeaderSectionAdapter> ResourceParser;
 }
 
 #endif