redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/RegexMatch.h

@@ -17,13 +17,13 @@ namespace snowcrash {
     // Perform snowcrash-specific regex evaluation
     // returns true if target string matches given expression, false otherwise
     bool RegexMatch(const std::string& target, const std::string& expression);
-    
+
     // Performs posix-regex and returns first captured group (excluding whole target)
     std::string RegexCaptureFirst(const std::string& target, const std::string& expression);
-    
+
     // Array of capture groups
     typedef std::vector<std::string> CaptureGroups;
-    
+
     // Performs posix-regex
     // returns true if target string matches given expression, false otherwise
     bool RegexCapture(const std::string& target, const std::string& expression, CaptureGroups& captureGroups, size_t groupSize = 8);

data/ext/snowcrash/src/ResourceGroupParser.h

@@ -33,7 +33,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<ResourceGroup>& out) {
+                                                     const ParseResultRef<ResourceGroup>& out) {
 
             MarkdownNodeIterator cur = node;
             SectionType nestedType = nestedSectionType(cur);
@@ -61,11 +61,12 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<ResourceGroup>& out) {
+                                                         const ParseResultRef<ResourceGroup>& out) {
 
             if (pd.sectionContext() == ResourceSectionType) {
 
-                ParseResult<Resource> resource(out.report);
+                IntermediateParseResult<Resource> resource(out.report);
+
                 MarkdownNodeIterator cur = ResourceParser::parse(node, siblings, pd, resource);
 
                 ResourceIterator duplicate = SectionProcessor<Resource>::findResource(out.node.resources, resource.node);
@@ -101,7 +102,7 @@ namespace snowcrash {
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& lastSectionType,
-                                                          ParseResult<ResourceGroup>& out) {
+                                                          const ParseResultRef<ResourceGroup>& out) {
 
             if (SectionProcessor<Action>::actionType(node) == DependentActionType &&
                 !out.node.resources.empty()) {

data/ext/snowcrash/src/ResourceParser.h

@@ -17,10 +17,10 @@
 #include "RegexMatch.h"
 
 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 "]$";
 
@@ -37,7 +37,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Resource>& out) {
+                                                     const ParseResultRef<Resource>& out) {
 
             CaptureGroups captureGroups;
 
@@ -49,7 +49,8 @@ namespace snowcrash {
                 // Make this section an action
                 if (!captureGroups[2].empty()) {
 
-                    ParseResult<Action> action(out.report);
+                    IntermediateParseResult<Action> action(out.report);
+
                     MarkdownNodeIterator cur = ActionParser::parse(node, node->parent().children(), pd, action);
 
                     out.node.actions.push_back(action.node);
@@ -85,7 +86,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Resource>& out) {
+                                                         const ParseResultRef<Resource>& out) {
 
             switch (pd.sectionContext()) {
                 case ActionSectionType:
@@ -100,7 +101,7 @@ namespace snowcrash {
 
                 case HeadersSectionType:
                 {
-                    ParseResult<Headers> headers(out.report, out.node.headers, out.sourceMap.headers);
+                    ParseResultRef<Headers> headers(out.report, out.node.headers, out.sourceMap.headers);
                     return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, headers);
                 }
 
@@ -110,18 +111,18 @@ namespace snowcrash {
 
             return node;
         }
-        
+
         static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& sectionType,
-                                                          ParseResult<Resource>& out) {
-            
+                                                          const ParseResultRef<Resource>& out) {
+
             if ((node->type == mdp::ParagraphMarkdownNodeType ||
                  node->type == mdp::CodeMarkdownNodeType) &&
                 (sectionType == ModelBodySectionType ||
                  sectionType == ModelSectionType)) {
-                
+
                 mdp::ByteBuffer content = CodeBlockUtility::addDanglingAsset(node, pd, sectionType, out.report, out.node.model.body);
 
                 if (pd.exportSourceMap() && !content.empty()) {
@@ -130,7 +131,7 @@ namespace snowcrash {
 
                 // Update model in the symbol table as well
                 ResourceModelSymbolTable::iterator it = pd.symbolTable.resourceModels.find(out.node.model.name);
-                
+
                 if (it != pd.symbolTable.resourceModels.end()) {
                     it->second.body = out.node.model.body;
 
@@ -138,20 +139,20 @@ namespace snowcrash {
                         pd.symbolSourceMapTable.resourceModels[out.node.model.name].body = out.sourceMap.model.body;
                     }
                 }
-                
+
                 return ++MarkdownNodeIterator(node);
             }
-            
+
             return SectionProcessorBase<Resource>::processUnexpectedNode(node, siblings, pd, sectionType, out);
         }
-        
+
         static bool isDescriptionNode(const MarkdownNodeIterator& node,
                                       SectionType sectionType) {
-            
+
             if (SectionProcessor<Action>::actionType(node) == CompleteActionType) {
                 return false;
             }
-                
+
             return SectionProcessorBase<Resource>::isDescriptionNode(node, sectionType);
         }
 
@@ -205,12 +206,12 @@ namespace snowcrash {
             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;
             }
 
@@ -233,7 +234,7 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<Resource>& out) {
+                             const ParseResultRef<Resource>& out) {
 
             if (!out.node.uriTemplate.empty()) {
 
@@ -273,9 +274,10 @@ namespace snowcrash {
         static MarkdownNodeIterator processAction(const MarkdownNodeIterator& node,
                                                   const MarkdownNodes& siblings,
                                                   SectionParserData& pd,
-                                                  ParseResult<Resource>& out) {
+                                                  const ParseResultRef<Resource>& out) {
+
+            IntermediateParseResult<Action> action(out.report);
 
-            ParseResult<Action> action(out.report);
             MarkdownNodeIterator cur = ActionParser::parse(node, siblings, pd, action);
 
             ActionIterator duplicate = SectionProcessor<Action>::findAction(out.node.actions, action.node);
@@ -311,9 +313,10 @@ namespace snowcrash {
         static MarkdownNodeIterator processParameters(const MarkdownNodeIterator& node,
                                                       const MarkdownNodes& siblings,
                                                       SectionParserData& pd,
-                                                      ParseResult<Resource>& out) {
+                                                      const ParseResultRef<Resource>& out) {
+
+            IntermediateParseResult<Parameters> parameters(out.report);
 
-            ParseResult<Parameters> parameters(out.report);
             MarkdownNodeIterator cur = ParametersParser::parse(node, siblings, pd, parameters);
 
             if (!parameters.node.empty()) {
@@ -335,9 +338,10 @@ namespace snowcrash {
         static MarkdownNodeIterator processModel(const MarkdownNodeIterator& node,
                                                  const MarkdownNodes& siblings,
                                                  SectionParserData& pd,
-                                                 ParseResult<Resource>& out) {
+                                                 const ParseResultRef<Resource>& out) {
+
+            IntermediateParseResult<Payload> model(out.report);
 
-            ParseResult<Payload> model(out.report);
             MarkdownNodeIterator cur = PayloadParser::parse(node, siblings, pd, model);
 
             // Check whether there isn't a model already
@@ -417,7 +421,7 @@ namespace snowcrash {
         static void checkParametersEligibility(const MarkdownNodeIterator& node,
                                                const SectionParserData& pd,
                                                Parameters& parameters,
-                                               ParseResult<Resource>& out) {
+                                               const ParseResultRef<Resource>& out) {
 
             for (ParameterIterator it = parameters.begin();
                  it != parameters.end();

data/ext/snowcrash/src/Section.cc

@@ -16,26 +16,26 @@ std::string snowcrash::SectionName(const SectionType& section) {
         case ModelSectionType:
         case ModelBodySectionType:
             return "model";
-            
+
         case RequestSectionType:
         case RequestBodySectionType:
             return "request";
-            
+
         case ResponseSectionType:
         case ResponseBodySectionType:
             return "response";
-            
+
         case BodySectionType:
         case DanglingBodySectionType:
             return "message-body";
-            
+
         case SchemaSectionType:
         case DanglingSchemaSectionType:
             return "message-schema";
-            
+
         case HeadersSectionType:
             return "headers";
-            
+
         default:
             return "section";
     }

data/ext/snowcrash/src/Section.h

@@ -12,7 +12,7 @@
 #include <string>
 
 namespace snowcrash {
-    
+
     /**
      *  API Blueprint Sections Types.
      */
@@ -39,7 +39,7 @@ namespace snowcrash {
         ValuesSectionType,              /// < Value enumeration
         ValueSectionType                /// < One Value
     };
-    
+
     /** \return Human readable name for given %SectionType */
     extern std::string SectionName(const SectionType& section);
 }

data/ext/snowcrash/src/SectionParser.h

@@ -22,7 +22,7 @@ namespace snowcrash {
     template<typename T, typename Adapter>
     struct SectionParser {
 
-        
+
         /**
          *  \brief  Parse a section of blueprint
          *  \param  node    Initial node to start parsing at
@@ -34,12 +34,12 @@ namespace snowcrash {
         static MarkdownNodeIterator parse(const MarkdownNodeIterator& node,
                                           const MarkdownNodes& siblings,
                                           SectionParserData& pd,
-                                          ParseResult<T>& out) {
-            
+                                          const ParseResultRef<T>& out) {
+
             SectionLayout layout = DefaultSectionLayout;
             MarkdownNodeIterator cur = Adapter::startingNode(node);
             const MarkdownNodes& collection = Adapter::startingNodeSiblings(node, siblings);
-            
+
             // Signature node
             MarkdownNodeIterator lastCur = cur;
             cur = SectionProcessor<T>::processSignature(cur, collection, pd, layout, out);
@@ -48,45 +48,45 @@ namespace snowcrash {
             if (layout == ExclusiveNestedSectionLayout) {
 
                 cur = parseNestedSections(cur, collection, pd, out);
-                
+
                 SectionProcessor<T>::finalize(node, pd, out);
-                
+
                 return Adapter::nextStartingNode(node, siblings, cur);
             }
-            
+
             // Parser redirect layout
             if (layout == RedirectSectionLayout) {
                 SectionProcessor<T>::finalize(node, pd, out);
-                
+
                 return Adapter::nextStartingNode(node, siblings, cur);
             }
 
             // Default layout
             if (lastCur == cur)
                 return Adapter::nextStartingNode(node, siblings, cur);
-            
+
             // Description nodes
             while(cur != collection.end() &&
                   SectionProcessor<T>::isDescriptionNode(cur, pd.sectionContext())) {
-                
+
                 lastCur = cur;
                 cur = SectionProcessor<T>::processDescription(cur, collection, pd, out);
 
                 if (lastCur == cur)
                     return Adapter::nextStartingNode(node, siblings, cur);
             }
-            
+
             // Content nodes
             while(cur != collection.end() &&
                   SectionProcessor<T>::isContentNode(cur, pd.sectionContext())) {
-                
+
                 lastCur = cur;
                 cur = SectionProcessor<T>::processContent(cur, collection, pd, out);
 
                 if (lastCur == cur)
                     return Adapter::nextStartingNode(node, siblings, cur);
             }
-            
+
             // Nested Sections
             cur = parseNestedSections(cur, collection, pd, out);
 
@@ -94,27 +94,27 @@ namespace snowcrash {
 
             return Adapter::nextStartingNode(node, siblings, cur);
         }
-        
-        
+
+
         /** Parse nested sections */
         static MarkdownNodeIterator parseNestedSections(const MarkdownNodeIterator& node,
                                                         const MarkdownNodes& collection,
                                                         SectionParserData& pd,
-                                                        ParseResult<T>& out) {
+                                                        const ParseResultRef<T>& out) {
 
             MarkdownNodeIterator cur = node;
             MarkdownNodeIterator lastCur = cur;
-            
+
             SectionType lastSectionType = UndefinedSectionType;
-            
+
             // Nested sections
             while(cur != collection.end()) {
-                
+
                 lastCur = cur;
                 SectionType nestedType = SectionProcessor<T>::nestedSectionType(cur);
-                
+
                 pd.sectionsContext.push_back(nestedType);
-                
+
                 if (nestedType != UndefinedSectionType) {
                     cur = SectionProcessor<T>::processNestedSection(cur, collection, pd, out);
                 }
@@ -123,50 +123,50 @@ namespace snowcrash {
 
                     cur = SectionProcessor<T>::processUnexpectedNode(cur, collection, pd, lastSectionType, out);
                 }
-                
+
                 if (cur != collection.end() &&
                     (pd.sectionContext() != UndefinedSectionType ||
                      (cur->type != mdp::ParagraphMarkdownNodeType &&
                       cur->type != mdp::CodeMarkdownNodeType))) {
-                         
+
                     lastSectionType = pd.sectionContext();
                 }
-                
+
                 pd.sectionsContext.pop_back();
-                
+
                 if (lastCur == cur)
                     break;
             }
-            
+
             return cur;
         }
     };
-    
+
     /** Parser Adapter for parsing header-defined sections */
     struct HeaderSectionAdapter {
-        
+
         /** \return Node to start parsing with */
         static const MarkdownNodeIterator startingNode(const MarkdownNodeIterator& seed) {
             if (seed->type != mdp::HeaderMarkdownNodeType)
                 throw ADAPTER_MISMATCH_ERR;
-            
+
             return seed;
         }
-        
+
         /** \return Collection of siblings to starting Node */
         static const MarkdownNodes& startingNodeSiblings(const MarkdownNodeIterator& seed,
                                                          const MarkdownNodes& siblings) {
             return siblings;
         }
-        
+
         /** \return Starting node for next parsing */
         static const MarkdownNodeIterator nextStartingNode(const MarkdownNodeIterator& seed,
                                                            const MarkdownNodes& siblings,
                                                            const MarkdownNodeIterator& cur) {
             return cur;
         }
-        
-        /** 
+
+        /**
          *  \brief Adapter Markdown node skipping behavior trait.
          *
          *  Adapter trait signalizing that the adapter can possibly skip some Markdown nodes on a nextStartingNode() call.
@@ -174,31 +174,31 @@ namespace snowcrash {
          */
         static const bool nextSkipsUnexpected = false;
     };
-    
+
     /** Parser Adapter for parsing list-defined sections */
     struct ListSectionAdapter {
-        
+
         static const MarkdownNodeIterator startingNode(const MarkdownNodeIterator& seed) {
             if (seed->type != mdp::ListItemMarkdownNodeType)
                 throw ADAPTER_MISMATCH_ERR;
-            
+
             return seed->children().begin();
         }
-        
+
         static const MarkdownNodes& startingNodeSiblings(const MarkdownNodeIterator& seed,
                                                          const MarkdownNodes& siblings) {
             return seed->children();
         }
-        
+
         static const MarkdownNodeIterator nextStartingNode(const MarkdownNodeIterator& seed,
                                                            const MarkdownNodes& siblings,
                                                            const MarkdownNodeIterator& cur) {
             if (seed == siblings.end())
                 return seed;
-            
+
             return ++MarkdownNodeIterator(seed);
         }
-        
+
         static const bool nextSkipsUnexpected = true;
     };
 
@@ -222,7 +222,7 @@ namespace snowcrash {
                                                            const MarkdownNodeIterator& cur) {
             return cur;
         }
-        
+
         static const bool nextSkipsUnexpected = false;
     };
 }