redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/AssetParser.h

@@ -9,207 +9,118 @@
 #ifndef SNOWCRASH_ASSETPARSER_H
 #define SNOWCRASH_ASSETPARSER_H
 
-#include <sstream>
-#include "BlueprintParserCore.h"
-#include "Blueprint.h"
+#include "SectionParser.h"
 #include "RegexMatch.h"
-#include "StringUtility.h"
-#include "SectionUtility.h"
-
-namespace snowcrashconst {
-    
-    /** Body matching regex */
-    const char* const BodyRegex("^[[:blank:]]*[Bb]ody[[:blank:]]*$");
-
-    /** Schema matching regex */
-    const char* const SchemaRegex("^[[:blank:]]*[Ss]chema[[:blank:]]*$");
-}
+#include "CodeBlockUtility.h"
 
 namespace snowcrash {
     
     /// Asset signature
     enum AssetSignature {
-        UndefinedAssetSignature,
-        NoAssetSignature,
+        NoAssetSignature = 0,
         BodyAssetSignature,         /// < Explicit body asset
-        PayloadBodyAssetSignature,  /// < Body asset using abbreviated syntax
+        ImplicitBodyAssetSignature, /// < Body asset using abbreviated syntax
         SchemaAssetSignature,       /// < Explicit Schema asset
-        GenericAssetSignature
+        UndefinedAssetSignature = -1
     };
     
-    // Query asset signature a of given block
-    FORCEINLINE AssetSignature GetAssetSignature(const BlockIterator& begin,
-                                                 const BlockIterator& end) {
-        
-        if (begin->type == ListBlockBeginType || begin->type == ListItemBlockBeginType) {
-            
-            BlockIterator cur = ListItemNameBlock(begin, end);
-            if (cur == end)
-                return NoAssetSignature;
-            
-            if (cur->type != ParagraphBlockType &&
-                cur->type != ListItemBlockEndType)
-                return NoAssetSignature;
-            
-            std::string content = GetFirstLine(cur->content);
-            if (RegexMatch(content, snowcrashconst::BodyRegex))
-                return BodyAssetSignature;
+    /** Body matching regex */
+    const char* const BodyRegex = "^[[:blank:]]*[Bb]ody[[:blank:]]*$";
+
+    /** Schema matching regex */
+    const char* const SchemaRegex = "^[[:blank:]]*[Ss]chema[[:blank:]]*$";
 
-            if (RegexMatch(content, snowcrashconst::SchemaRegex))
-                return SchemaAssetSignature;
-            
-            if (HasPayloadAssetSignature(begin, end))
-                return PayloadBodyAssetSignature;
-        }
-        
-        return NoAssetSignature;
-    }
-    
-    FORCEINLINE bool HasAssetSignature(const BlockIterator& begin,
-                                       const BlockIterator& end) {
-        AssetSignature signature = GetAssetSignature(begin, end);
-        return (signature != NoAssetSignature);
-    }
-    
-    /**
-     *  Return true if given block might be a dangling asset block,
-     *  false otherwise.
-     */
-    FORCEINLINE bool IsDanglingBlock(const BlockIterator& begin, const BlockIterator& end) {
-        return (begin->type == ParagraphBlockType
-                || begin->type == CodeBlockType);
-    }
-    
     /**
-     *  Block Classifier, asset context.
+     *  Asset Section Processor
      */
-    template <>
-    FORCEINLINE SectionType ClassifyBlock<Asset>(const BlockIterator& begin,
-                                                 const BlockIterator& end,
-                                                 const SectionType& context) {
+    template<>
+    struct SectionProcessor<Asset> : public SectionProcessorBase<Asset> {
         
-        if (context == UndefinedSectionType) {
-            AssetSignature asset = GetAssetSignature(begin, end);
-            if (asset == BodyAssetSignature || asset == PayloadBodyAssetSignature)
-                return BodySectionType;
-            if (asset == SchemaAssetSignature)
-                return SchemaSectionType;
-        }
-        else if (context == BodySectionType ||
-                 context == SchemaSectionType) {
-            
-            // SectionType closure
-            if (begin->type == ListItemBlockEndType ||
-                begin->type == ListBlockEndType) {
-
-                // Look ahead for a dangling asset
-                BlockIterator cur = CloseNestedList(begin, end);
-                if (cur == end)
-                    return UndefinedSectionType;
-                
-                if (IsDanglingBlock(cur, end))
-                    return (context == BodySectionType) ? DanglingBodySectionType : DanglingSchemaSectionType;
-                else
-                    return UndefinedSectionType;
-            }
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     Report& report,
+                                                     Asset& out) {
             
-            // Adjacent list item
-            if (begin->type == ListItemBlockBeginType) {
-                    return UndefinedSectionType;
-            }
+            out = "";
+            CodeBlockUtility::signatureContentAsCodeBlock(node, pd, report, out);
+            return ++MarkdownNodeIterator(node);
         }
-        else if (context == DanglingBodySectionType ||
-                 context == DanglingSchemaSectionType) {
+        
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       Report& report,
+                                                       Asset& out) {
+            return node;
+        }
+
+        static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
+                                                   const MarkdownNodes& siblings,
+                                                   SectionParserData& pd,
+                                                   Report& report,
+                                                   Asset& out) {
             
-            if (begin->type == ListItemBlockEndType ||
-                begin->type == ListBlockEndType)
-                return UndefinedSectionType;
             
-            if (!IsDanglingBlock(begin, end))
-                return UndefinedSectionType;
+            mdp::ByteBuffer content;
+            CodeBlockUtility::contentAsCodeBlock(node, pd, report, content);
+            out += content;
+            return ++MarkdownNodeIterator(node);
         }
         
-        return (context == BodySectionType ||
-                context == SchemaSectionType ||
-                context == DanglingBodySectionType ||
-                context == DanglingSchemaSectionType) ? context : UndefinedSectionType;
-    }
-    
-    //
-    // Asset SectionType Parser
-    //
-    template<>
-    struct SectionParser<Asset> {
-        
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               Asset& asset) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            switch (section.type) {
-                case BodySectionType:
-                case SchemaSectionType: 
-                    result = HandleAssetSectionBlock(section, cur, parser, asset);
-                    break;
-                    
-                case DanglingBodySectionType:
-                case DanglingSchemaSectionType:
-                    result = HandleDanglingAssetSectionBlock(section, cur, parser, asset);
-                    break;
-                    
-                case UndefinedSectionType:
-                    result.second = CloseList(cur, section.bounds.second);
-                    break;
-                    
-                default:
-                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
-                    break;
-            }
-            
-            return result;
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+            return false;
         }
         
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             Asset& asset,
-                             Result& result) {}
+        static bool isContentNode(const MarkdownNodeIterator& node,
+                                  SectionType sectionType) {
+
+            return (SectionKeywordSignature(node) == UndefinedSectionType);
+        }
         
-        static ParseSectionResult HandleAssetSectionBlock(const BlueprintSection& section,
-                                                          const BlockIterator& cur,
-                                                          BlueprintParserCore& parser,
-                                                          Asset& asset) {
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
 
-            SourceData data;
-            SourceDataBlock sourceMap;
-            // NOTE: Use `Payload` traits for parsing pre-formatted list block.
-            ParseSectionResult result = ParseListPreformattedBlock<Payload>(section,
-                                                                            cur,
-                                                                            parser,
-                                                                            data,
-                                                                            sourceMap);
-            if (result.first.error.code != Error::OK ||
-                parser.sourceData.empty())
-                return result;
-            
-            asset += data;
-            return result;
+                AssetSignature signature = assetSignature(node);
+
+                switch (signature) {
+                    case BodyAssetSignature:
+                    case ImplicitBodyAssetSignature:
+                        return BodySectionType;
+
+                    case SchemaAssetSignature:
+                        return SchemaSectionType;
+                        
+                    default:
+                        return UndefinedSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
         }
         
-        static ParseSectionResult HandleDanglingAssetSectionBlock(const BlueprintSection& section,
-                                                                  const BlockIterator& cur,
-                                                                  BlueprintParserCore& parser,
-                                                                  Asset& asset) {
+        /** Resolve asset signature */
+        static AssetSignature assetSignature(const MarkdownNodeIterator& node) {
+
+            mdp::ByteBuffer remaining, subject = node->children().front().text;
+            subject = GetFirstLine(subject, remaining);
+            TrimString(subject);
             
-            // Skip any closing list blocks
-            BlockIterator sectionCur = CloseNestedList(cur, section.bounds.second);
-            return HandleAssetSectionBlock(section, sectionCur, parser, asset);
-        }
+            if (RegexMatch(subject, BodyRegex))
+                return BodyAssetSignature;
 
+            if (RegexMatch(subject, SchemaRegex))
+                return SchemaAssetSignature;
+            
+            return NoAssetSignature;
+        }
     };
     
-    typedef BlockParser<Asset, SectionParser<Asset> > AssetParser;
-
+    /** Asset Section Parser */
+    typedef SectionParser<Asset, ListSectionAdapter> AssetParser;
 }
 
 #endif

data/ext/snowcrash/src/Blueprint.h

@@ -48,7 +48,7 @@ namespace snowcrash {
     
     /** Parameter Value */
     typedef std::string Value;
-     
+
     /** A generic key - value pair */
     typedef std::pair<std::string, std::string> KeyValuePair;
     
@@ -113,6 +113,8 @@ namespace snowcrash {
         Collection<Value>::type values;
     };
 
+    /** Name of a symbol */
+    typedef std::string SymbolName;
     
     /**
      *  Payload
@@ -136,6 +138,9 @@ namespace snowcrash {
         
         /** Schema */
         Asset schema;
+
+        /** Symbol */
+        SymbolName symbol;
     };
     
     /** Resource Model */
@@ -257,7 +262,7 @@ namespace snowcrash {
         /** Resources */
         Collection<Resource>::type resources;
     };
-    
+
     /** 
      *  \brief API Blueprint AST
      *

data/ext/snowcrash/src/BlueprintParser.h

@@ -9,339 +9,265 @@
 #ifndef SNOWCRASH_BLUEPRINTPARSER_H
 #define SNOWCRASH_BLUEPRINTPARSER_H
 
-#include <functional>
-#include <sstream>
-#include <iterator>
-#include "Blueprint.h"
-#include "BlueprintParserCore.h"
 #include "ResourceParser.h"
 #include "ResourceGroupParser.h"
+#include "SectionParser.h"
+#include "RegexMatch.h"
+#include "CodeBlockUtility.h"
+
+namespace snowcrash {
 
-namespace snowcrashconst {
-    
     const char* const ExpectedAPINameMessage = "expected API name, e.g. '# <API Name>'";
-}
 
-namespace snowcrash {
+    /** Internal type alias for Collection of Metadata */
+    typedef Collection<Metadata>::type MetadataCollection;
 
-    /** Internal list items classifier, Blueprint Context */
-    template <>
-    FORCEINLINE SectionType ClassifyInternaListBlock<Blueprint>(const BlockIterator& begin,
-                                                                const BlockIterator& end) {
-        return UndefinedSectionType;
-    }
-    
-    /** Block Classifier, Blueprint Context */
-    template <>
-    FORCEINLINE SectionType ClassifyBlock<Blueprint>(const BlockIterator& begin,
-                                                     const BlockIterator& end,
-                                                     const SectionType& context) {
-        
-        if (HasResourceGroupSignature(*begin) ||
-            HasResourceSignature(*begin))
-            return ResourceGroupSectionType; // Treat Resource as anonymous resource group
-        
-        return (context == ResourceGroupSectionType) ? UndefinedSectionType : BlueprintSectionType;
-    }
-    
-
-    /** Blueprint SectionType Parser */
+    typedef Collection<Metadata>::iterator MetadataCollectionIterator;
+
+    /**
+     * Blueprint processor
+     */
     template<>
-    struct SectionParser<Blueprint> {
-        
-        static ParseSectionResult ParseSection(const BlueprintSection& section,
-                                               const BlockIterator& cur,
-                                               BlueprintParserCore& parser,
-                                               Blueprint& output) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            
-            switch (section.type) {
-                    
-                case BlueprintSectionType:
-                    result = HandleBlueprintDescriptionBlock(section, cur, parser, output);
-                    break;
-                    
-                case ResourceGroupSectionType:
-                    result = HandleResourceGroup(section, cur, parser, output);
-                    break;
-                    
-                default:
-                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
-                    break;
+    struct SectionProcessor<Blueprint> : public SectionProcessorBase<Blueprint> {
+
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     Report& report,
+                                                     Blueprint& out) {
+
+            MarkdownNodeIterator cur = node;
+
+            while (cur != siblings.end() &&
+                   cur->type == mdp::ParagraphMarkdownNodeType) {
+
+                MetadataCollection metadata;
+                parseMetadata(cur, pd, report, metadata);
+
+                // First block is paragraph and is not metadata (no API name)
+                if (metadata.empty()) {
+                    return processDescription(cur, siblings, pd, report, out);
+                } else {
+                    out.metadata.insert(out.metadata.end(), metadata.begin(), metadata.end());
+                }
+
+                cur++;
             }
             
-            return result;
-        }
-        
-        static void Finalize(const SectionBounds& bounds,
-                             BlueprintParserCore& parser,
-                             Blueprint& blueprint,
-                             Result& result) {}
-        
-        /**
-         *  \brief  Checks API Blueprint name issues warning or error if name does not exists.
-         *  \param  cur     Cursor to the expected name header block
-         *  \param  blueprint   Blueprint to check.
-         *  \param  parser  A parser's instance.
-         *  \param  result  Check result report.
-         *  \result Returns false if a name is missing AND RequireBlueprintNameOption is set. True otherwise.
-         */
-        static bool CheckBlueprintName(const BlockIterator& cur,
-                                       const Blueprint& blueprint,
-                                       BlueprintParserCore& parser,
-                                       Result& result) {
-
-            if (!blueprint.name.empty())
-                return true;
-
-            if (parser.options & RequireBlueprintNameOption) {
-                
-                // ERR: No API name specified
-                result.error = Error(snowcrashconst::ExpectedAPINameMessage,
-                                     BusinessError,
-                                     MapSourceDataBlock(cur->sourceMap, parser.sourceData));
-                return false;
+            // Ideally this parsing metadata should be handled by separate parser
+            // that way the following check would be covered in SectionParser::parse()
+            if (cur == siblings.end())
+                return cur;
+
+            if (cur->type == mdp::HeaderMarkdownNodeType) {
+
+                SectionType nestedType = nestedSectionType(cur);
+
+                // Resources Groups only, parse as exclusive nested sections
+                if (nestedType != UndefinedSectionType) {
+                    layout = ExclusiveNestedSectionLayout;
+                    return cur;
+                }
+
+                out.name = cur->text;
+                TrimString(out.name);
+            } else {
+
+                // Any other type of block, add to description
+                return processDescription(cur, siblings, pd, report, out);
             }
 
-            // WARN: No API name specified
-            result.warnings.push_back(Warning(snowcrashconst::ExpectedAPINameMessage,
-                                              APINameWarning,
-                                              MapSourceDataBlock(cur->sourceMap, parser.sourceData)));
+            return ++MarkdownNodeIterator(cur);
+        }
 
-            return true;
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         Report& report,
+                                                         Blueprint& out) {
+
+            if (pd.sectionContext() == ResourceGroupSectionType ||
+                pd.sectionContext() == ResourceSectionType) {
+
+                ResourceGroup resourceGroup;
+                MarkdownNodeIterator cur = ResourceGroupParser::parse(node, siblings, pd, report, resourceGroup);
+
+                ResourceGroupIterator duplicate = findResourceGroup(out.resourceGroups, resourceGroup);
+
+                if (duplicate != out.resourceGroups.end()) {
+
+                    // WARN: duplicate resource group
+                    std::stringstream ss;
+
+                    if (resourceGroup.name.empty()) {
+                        ss << "anonymous group";
+                    } else {
+                        ss << "group '" << resourceGroup.name << "'";
+                    }
+
+                    ss << " is already defined";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.warnings.push_back(Warning(ss.str(),
+                                                      DuplicateWarning,
+                                                      sourceMap));
+                }
+
+                out.resourceGroups.push_back(resourceGroup);
+
+                return cur;
+            }
+
+            return node;
         }
-        
-        // Returns true if given block is first block in document
-        // after metadata block, false otherwise.
-        static bool IsFirstBlock(const BlockIterator& cur,
-                                 const SectionBounds& bounds,
-                                 const Blueprint& blueprint) {
-            
-            if (blueprint.metadata.empty())
-                return cur == bounds.first;
-            
-            return std::distance(bounds.first, cur) == 1;
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            return BlueprintSectionType;
         }
 
-        static ParseSectionResult HandleBlueprintDescriptionBlock(const BlueprintSection& section,
-                                                                  const BlockIterator& cur,
-                                                                  BlueprintParserCore& parser,
-                                                                  Blueprint& output) {
-            
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            BlockIterator sectionCur(cur);
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
 
-            // API Name
-            bool isFirstBlock = IsFirstBlock(cur, section.bounds, output);
-            if (isFirstBlock &&
-                sectionCur->type == HeaderBlockType) {
-                
-                output.name = cur->content;
-                
-                // Check ambiguity
-                CheckHeaderBlock<Blueprint>(section, sectionCur, parser.sourceData, result.first);
+            SectionType nestedType = UndefinedSectionType;
 
-                // Check Name
-                if (!CheckBlueprintName(sectionCur, output, parser, result.first))
-                    return result;
-                
-                result.second = ++sectionCur;
-                return result;
+            // Check if Resource section
+            nestedType = SectionProcessor<Resource>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
             }
-            
-            // Metadata
-            if (isFirstBlock &&
-                sectionCur->type == ParagraphBlockType) {
-                
-                result = ParseMetadataBlock(sectionCur, section.bounds, parser, output);
-                if (result.second != sectionCur)
-                    return result;
+
+            // Check if ResourceGroup section
+            nestedType = SectionProcessor<ResourceGroup>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
             }
-            
-            // Description
-            result = ParseDescriptionBlock<Blueprint>(section, sectionCur, parser.sourceData, output);
-            
-            // Check Name
-            if (isFirstBlock)
-                CheckBlueprintName(sectionCur, output, parser, result.first);
-            
-            return result;
+
+            return UndefinedSectionType;
         }
-        
-        static ParseSectionResult HandleResourceGroup(const BlueprintSection& section,
-                                                      const BlockIterator& cur,
-                                                      BlueprintParserCore& parser,
-                                                      Blueprint& output)
-        {
-            
-            // Mandatory name check
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            if (IsFirstBlock(cur, section.bounds, output) &&
-                !CheckBlueprintName(cur, output, parser, result.first))
-                return result;
-            
-            // Parser resource group
-            ResourceGroup resourceGroup;
-            result = ResourceGroupParser::Parse(cur,
-                                                section.bounds.second,
-                                                section,
-                                                parser,
-                                                resourceGroup);
-
-            if (result.first.error.code != Error::OK)
-                return result;
+
+        static SectionTypes nestedSectionTypes() {
+            SectionTypes nested;
+
+            // Resource Group & descendants
+            nested.push_back(ResourceGroupSectionType);
+            SectionTypes types = SectionProcessor<ResourceGroup>::nestedSectionTypes();
+            nested.insert(nested.end(), types.begin(), types.end());
+
+            return nested;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             Report& report,
+                             Blueprint& out) {
             
-            Collection<ResourceGroup>::const_iterator duplicate = FindResourceGroup(parser.blueprint, resourceGroup);
-            if (duplicate != parser.blueprint.resourceGroups.end()) {
-                
-                // WARN: duplicate group
-                std::stringstream ss;
-                if (resourceGroup.name.empty()) {
-                    ss << "anonymous group";
-                }
-                else {
-                    ss << "group '" << resourceGroup.name << "'";
-                }
-                ss << " is already defined";
+            if (!out.name.empty())
+                return;
+
+            if (pd.options & RequireBlueprintNameOption) {
+
+                // ERR: No API name specified
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.error = Error(ExpectedAPINameMessage,
+                                     BusinessError,
+                                     sourceMap);
                 
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, section.bounds.second, section.bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning(ss.str(),
-                                                        DuplicateWarning,
-                                                        sourceBlock));
             }
-            
-            output.resourceGroups.push_back(resourceGroup); // FIXME: C++11 move
-            return result;
+            else if (!out.description.empty()) {
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ExpectedAPINameMessage,
+                                                  APINameWarning,
+                                                  sourceMap));
+            }
         }
-        
 
-        static ParseSectionResult ParseMetadataBlock(const BlockIterator& cur,
-                                                     const SectionBounds& bounds,
-                                                     BlueprintParserCore& parser,
-                                                     Blueprint& output) {
-            
-            typedef Collection<Metadata>::type MetadataCollection;
-            typedef Collection<Metadata>::iterator MetadataCollectionIterator;
-            MetadataCollection metadataCollection;
+        static bool isUnexpectedNode(const MarkdownNodeIterator& node,
+                                     SectionType sectionType) {
             
-            ParseSectionResult result = std::make_pair(Result(), cur);
-            SourceData content = cur->content;
+            // Since Blueprint is currently top-level node any unprocessed node should be reported
+            return true;
+        }
+
+
+        static void parseMetadata(const MarkdownNodeIterator& node,
+                                  SectionParserData& pd,
+                                  Report& report,
+                                  MetadataCollection& out) {
+
+            mdp::ByteBuffer content = node->text;
             TrimStringEnd(content);
-            std::vector<std::string> lines = Split(content, '\n');
-            for (std::vector<std::string>::iterator line = lines.begin();
-                 line != lines.end();
-                 ++line) {
-                
+
+            std::vector<mdp::ByteBuffer> lines = Split(content, '\n');
+
+            for (std::vector<mdp::ByteBuffer>::iterator it = lines.begin();
+                 it != lines.end();
+                 ++it) {
+
                 Metadata metadata;
-                if (KeyValueFromLine(*line, metadata))
-                    metadataCollection.push_back(metadata);
+
+                if (CodeBlockUtility::keyValueFromLine(*it, metadata)) {
+                    out.push_back(metadata);
+                }
             }
-            
-            if (lines.size() == metadataCollection.size()) {
-                
+
+            if (lines.size() == out.size()) {
+
                 // Check duplicates
-                std::vector<std::string> duplicateKeys;
-                for (MetadataCollectionIterator it = metadataCollection.begin();
-                     it != metadataCollection.end();
+                std::vector<mdp::ByteBuffer> duplicateKeys;
+
+                for (MetadataCollectionIterator it = out.begin();
+                     it != out.end();
                      ++it) {
-                    
+
                     MetadataCollectionIterator from = it;
-                    if (++from == metadataCollection.end())
+                    if (++from == out.end())
                         break;
-                    
+
                     MetadataCollectionIterator duplicate = std::find_if(from,
-                                                                        metadataCollection.end(),
+                                                                        out.end(),
                                                                         std::bind2nd(MatchFirsts<Metadata>(), *it));
-                    
-                    if (duplicate != metadataCollection.end() &&
+
+                    if (duplicate != out.end() &&
                         std::find(duplicateKeys.begin(), duplicateKeys.end(), it->first) == duplicateKeys.end()) {
-                        
+
                         duplicateKeys.push_back(it->first);
-                        
-                        // WARN: duplicate metada definition
+
+                        // WARN: duplicate metadata definition
                         std::stringstream ss;
                         ss << "duplicate definition of '" << it->first << "'";
-                        
-                        SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, bounds.second, bounds, parser.sourceData);
-                        result.first.warnings.push_back(Warning(ss.str(),
-                                                                DuplicateWarning,
-                                                                sourceBlock));
+
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                        report.warnings.push_back(Warning(ss.str(),
+                                                          DuplicateWarning,
+                                                          sourceMap));
                     }
                 }
-                
-                // Insert parsed metadata into output
-                output.metadata.insert(output.metadata.end(),
-                                       metadataCollection.begin(),
-                                       metadataCollection.end());
-                
-                ++result.second;
             }
-            else if (!metadataCollection.empty()) {
+            else if (!out.empty()) {
+
                 // WARN: malformed metadata block
-                SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur, bounds.second, bounds, parser.sourceData);
-                result.first.warnings.push_back(Warning("ignoring possible metadata, expected"
-                                                        " '<key> : <value>', one one per line",
-                                                        FormattingWarning,
-                                                        sourceBlock));
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning("ignoring possible metadata, expected '<key> : <value>', one one per line",
+                                                  FormattingWarning,
+                                                  sourceMap));
             }
-            
-            return result;
         }
-    };
-    
-    typedef BlockParser<Blueprint, SectionParser<Blueprint> > BlueprintParserInner;
-    
-    
-    //
-    // Blueprint Parser
-    //
-    class BlueprintParser {
-    public:
-        // Parse Markdown AST into API Blueprint AST
-        static void Parse(const SourceData& sourceData,
-                          const MarkdownBlock::Stack& source,
-                          BlueprintParserOptions options,
-                          Result& result,
-                          Blueprint& blueprint) {
-            
-            BlueprintParserCore parser(options, sourceData, blueprint);
-            BlueprintSection rootSection(std::make_pair(source.begin(), source.end()));
-            ParseSectionResult sectionResult = BlueprintParserInner::Parse(source.begin(),
-                                                                           source.end(),
-                                                                           rootSection,
-                                                                           parser,
-                                                                           blueprint);
-            result += sectionResult.first;
-            
-#ifdef DEBUG
-            PrintSymbolTable(parser.symbolTable);
-#endif
-            if (result.error.code != Error::OK)
-                return;
-            
-            PostParseCheck(sourceData, source, parser, result);
-        }
-        
-        /** 
-         *  Perform additional post-parsing result checks.
-         *  Mainly to focused on running checking when top-level parser is not executed.
-         */
-        static void PostParseCheck(const SourceData& sourceData,
-                                   const MarkdownBlock::Stack& source,
-                                   BlueprintParserCore& parser,
-                                   Result& result) {
-            
-            if ((parser.options & RequireBlueprintNameOption) &&
-                parser.blueprint.name.empty()){
-                
-                // ERR: No API name specified
-                result.error = Error(snowcrashconst::ExpectedAPINameMessage,
-                                     BusinessError,
-                                     MapSourceDataBlock(MakeSourceDataBlock(0, 0), parser.sourceData));
-            }
+
+        /** Finds a resource group inside an resource groups collection */
+        static ResourceGroupIterator findResourceGroup(const ResourceGroups& resourceGroups,
+                                                       const ResourceGroup& resourceGroup) {
+
+            return std::find_if(resourceGroups.begin(),
+                                resourceGroups.end(),
+                                std::bind2nd(MatchName<ResourceGroup>(), resourceGroup));
         }
     };
+
+    /** Blueprint Parser */
+    typedef SectionParser<Blueprint, BlueprintSectionAdapter> BlueprintParser;
 }
 
 #endif