redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/ParameterParser.h

@@ -39,13 +39,13 @@ namespace snowcrash {
 
     /** Additonal Parameter Traits Type matching regex */
     const char* const AdditionalTraitsTypeRegex = CSV_LEADINOUT "([^,]*)" CSV_LEADINOUT;
-    
+
     /** Parameter Values matching regex */
     const char* const ParameterValuesRegex = "^[[:blank:]]*[Vv]alues[[:blank:]]*$";
 
     /** Values expected content */
     const char* const ExpectedValuesContent = "nested list of possible parameter values, one element per list item e.g. '`value`'";
-    
+
     /** Parameter description delimiter */
     const std::string DescriptionIdentifier = "...";
 
@@ -59,7 +59,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Parameter>& out) {
+                                                     const ParseResultRef<Parameter>& out) {
 
             mdp::ByteBuffer signature, remainingContent;
             signature = GetFirstLine(node->text, remainingContent);
@@ -81,7 +81,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Parameter>& out) {
+                                                         const ParseResultRef<Parameter>& out) {
 
             if (pd.sectionContext() != ValuesSectionType) {
                 return node;
@@ -107,7 +107,7 @@ namespace snowcrash {
                 out.sourceMap.values.collection.clear();
             }
 
-            ParseResult<Values> values(out.report, out.node.values, out.sourceMap.values);
+            ParseResultRef<Values> values(out.report, out.node.values, out.sourceMap.values);
             ValuesParser::parse(node, siblings, pd, values);
 
             if (out.node.values.empty()) {
@@ -163,7 +163,7 @@ namespace snowcrash {
         static void parseSignature(const mdp::MarkdownNodeIterator& node,
                                    SectionParserData& pd,
                                    mdp::ByteBuffer& signature,
-                                   ParseResult<Parameter>& out) {
+                                   const ParseResultRef<Parameter>& out) {
 
             out.node.use = UndefinedParameterUse;
 
@@ -172,10 +172,10 @@ namespace snowcrash {
             CaptureGroups captureGroups;
 
             if (isValidParameterSignature(signature)) {
-                
+
                 mdp::ByteBuffer innerSignature = signature;
                 innerSignature = TrimString(innerSignature);
-                
+
                 size_t firstSpace = innerSignature.find(" ");
 
                 if (firstSpace == std::string::npos) {
@@ -196,7 +196,7 @@ namespace snowcrash {
                         innerSignature = innerSignature.substr(0, descriptionPos);
                         innerSignature = TrimString(innerSignature);
                     }
-                    
+
                     size_t attributesPos = innerSignature.find("(");
 
                     if (attributesPos != std::string::npos) {
@@ -212,7 +212,7 @@ namespace snowcrash {
                             innerSignature = TrimString(innerSignature);
                         }
                     }
-                    
+
                     if (innerSignature.length() > 0) {
                         // Remove =
                         out.node.defaultValue = innerSignature;
@@ -264,7 +264,7 @@ namespace snowcrash {
         static void parseAdditionalTraits(const mdp::MarkdownNodeIterator& node,
                                           SectionParserData& pd,
                                           mdp::ByteBuffer& traits,
-                                          ParseResult<Parameter>& out) {
+                                          const ParseResultRef<Parameter>& out) {
 
             TrimString(traits);
 
@@ -351,7 +351,7 @@ namespace snowcrash {
 
         static void checkExampleAndDefaultValue(const mdp::MarkdownNodeIterator& node,
                                                 SectionParserData& pd,
-                                                ParseResult<Parameter>& out) {
+                                                const ParseResultRef<Parameter>& out) {
 
             bool isExampleFound = false;
             bool isDefaultFound = false;
@@ -395,23 +395,23 @@ namespace snowcrash {
                                                       sourceMap));
             }
         }
-        
+
         /** Determine if a signature is a valid parameter*/
         static bool isValidParameterSignature(const mdp::ByteBuffer& signature) {
-            
+
             mdp::ByteBuffer innerSignature = signature;
             innerSignature = TrimString(innerSignature);
-            
+
             if (innerSignature.length() == 0) {
                 return false; // Empty string, invalid
             }
-            
+
             size_t firstSpace = innerSignature.find(" ");
 
             if (firstSpace == std::string::npos) {
                 return RegexMatch(innerSignature, "^" PARAMETER_IDENTIFIER "$");
             }
-            
+
             std::string paramName = innerSignature.substr(0, firstSpace);
 
             if (!RegexMatch(paramName, "^" PARAMETER_IDENTIFIER "$")) {
@@ -427,7 +427,7 @@ namespace snowcrash {
                 innerSignature = innerSignature.substr(0, descriptionPos);
                 innerSignature = TrimString(innerSignature);
             }
-            
+
             size_t attributesPos = innerSignature.find("(");
 
             if (attributesPos != std::string::npos) {
@@ -441,11 +441,11 @@ namespace snowcrash {
                 innerSignature = innerSignature.substr(0, attributesPos);
                 innerSignature = TrimString(innerSignature);
             }
-            
+
             if (innerSignature.length() == 0) {
                 return true;
             }
-            
+
             if (innerSignature.substr(0,1) == "=") {
                 innerSignature = innerSignature.substr(1);
                 innerSignature = TrimString(innerSignature);
@@ -458,7 +458,7 @@ namespace snowcrash {
                     return true;
                 }
             }
-            
+
             return false;
         }
 

data/ext/snowcrash/src/ParametersParser.h

@@ -36,7 +36,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Parameters>& out) {
+                                                     const ParseResultRef<Parameters>& out) {
 
             mdp::ByteBuffer remainingContent;
 
@@ -61,7 +61,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       ParseResult<Parameters>& out) {
+                                                       const ParseResultRef<Parameters>& out) {
 
             return node;
         }
@@ -69,13 +69,14 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Parameters>& out) {
+                                                         const ParseResultRef<Parameters>& out) {
 
             if (pd.sectionContext() != ParameterSectionType) {
                 return node;
             }
 
-            ParseResult<Parameter> parameter(out.report);
+            IntermediateParseResult<Parameter> parameter(out.report);
+
             ParameterParser::parse(node, siblings, pd, parameter);
 
             if (!out.node.empty()) {
@@ -146,7 +147,7 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<Parameters>& out) {
+                             const ParseResultRef<Parameters>& out) {
 
             if (out.node.empty()) {
 

data/ext/snowcrash/src/PayloadParser.h

@@ -52,7 +52,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Payload>& out) {
+                                                     const ParseResultRef<Payload>& out) {
 
             mdp::ByteBuffer signature, remainingContent;
             signature = GetFirstLine(node->text, remainingContent);
@@ -97,16 +97,16 @@ namespace snowcrash {
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
                                                    SectionParserData& pd,
-                                                   ParseResult<Payload>& out) {
+                                                   const ParseResultRef<Payload>& out) {
 
             mdp::ByteBuffer content;
 
-            if (!out.node.symbol.empty()) {
+            if (!out.node.reference.id.empty()) {
                 //WARN: ignoring extraneous content after symbol reference
                 std::stringstream ss;
 
                 ss << "ignoring extraneous content after symbol reference";
-                ss << ", expected symbol reference only e.g. '[" << out.node.symbol << "][]'";
+                ss << ", expected symbol reference only e.g. '[" << out.node.reference.id << "][]'";
 
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                 out.report.warnings.push_back(Warning(ss.str(),
@@ -138,12 +138,12 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Payload>& out) {
+                                                         const ParseResultRef<Payload>& out) {
 
             switch (pd.sectionContext()) {
                 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 HeadersParser::parse(node, siblings, pd, headers);
                 }
 
@@ -157,7 +157,7 @@ namespace snowcrash {
                                                               sourceMap));
                     }
 
-                    ParseResult<Asset> asset(out.report, out.node.body, out.sourceMap.body);
+                    ParseResultRef<Asset> asset(out.report, out.node.body, out.sourceMap.body);
                     return AssetParser::parse(node, siblings, pd, asset);
                 }
 
@@ -171,7 +171,7 @@ namespace snowcrash {
                                                               sourceMap));
                     }
 
-                    ParseResult<Asset> asset(out.report, out.node.schema, out.sourceMap.schema);
+                    ParseResultRef<Asset> asset(out.report, out.node.schema, out.sourceMap.schema);
                     return AssetParser::parse(node, siblings, pd, asset);
                 }
 
@@ -186,7 +186,7 @@ namespace snowcrash {
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& sectionType,
-                                                          ParseResult<Payload>& out) {
+                                                          const ParseResultRef<Payload>& out) {
 
             if ((node->type == mdp::ParagraphMarkdownNodeType ||
                  node->type == mdp::CodeMarkdownNodeType) &&
@@ -200,7 +200,7 @@ namespace snowcrash {
 
                 return ++MarkdownNodeIterator(node);
             }
-            
+
             return SectionProcessorBase<Payload>::processUnexpectedNode(node, siblings, pd, sectionType, out);
         }
 
@@ -296,73 +296,16 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<Payload>& out) {
-
-            bool warnEmptyBody = false;
-
-            mdp::ByteBuffer contentLength;
-            mdp::ByteBuffer transferEncoding;
+                             const ParseResultRef<Payload>& out) {
 
             SectionType sectionType = pd.sectionContext();
 
-            for (HeaderIterator it = out.node.headers.begin();
-                 it != out.node.headers.end();
-                 ++it) {
+            if (sectionType == RequestSectionType || sectionType == RequestBodySectionType) {
 
-                if (it->first == HTTPHeaderName::ContentLength) {
-                    contentLength = it->second;
-                }
+                checkRequest(node, pd, out);
+            } else if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
 
-                if (it->first == HTTPHeaderName::TransferEncoding) {
-                    transferEncoding = it->second;
-                }
-            }
-
-            if ((sectionType == RequestSectionType || sectionType == RequestBodySectionType) && out.node.body.empty()) {
-
-                // Warn when content-length or transfer-encoding is specified or both headers and body are empty
-                if (out.node.headers.empty()) {
-                    warnEmptyBody = true;
-                } else {
-                    warnEmptyBody = !contentLength.empty() || !transferEncoding.empty();
-                }
-
-                if (warnEmptyBody) {
-                    // WARN: empty body
-                    std::stringstream ss;
-                    ss << "empty " << SectionName(sectionType) << " " << SectionName(BodySectionType);
-
-                    if (!contentLength.empty()) {
-                        ss << ", expected " << SectionName(BodySectionType) << " for '" << contentLength << "' Content-Length";
-                    } else if (!transferEncoding.empty()) {
-                        ss << ", expected " << SectionName(BodySectionType) << " for '" << transferEncoding << "' Transfer-Encoding";
-                    }
-
-                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    out.report.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          sourceMap));
-                }
-            } else if ((sectionType == ResponseSectionType || sectionType == ResponseBodySectionType)) {
-
-                HTTPStatusCode code = 200;
-
-                if (!out.node.name.empty()) {
-                    std::stringstream(out.node.name) >> code;
-                }
-
-                StatusCodeTraits statusCodeTraits = GetStatusCodeTrait(code);
-
-                if (!statusCodeTraits.allowBody && !out.node.body.empty()) {
-                    // WARN: not empty body
-                    std::stringstream ss;
-                    ss << "the " << code << " response MUST NOT include a " << SectionName(BodySectionType);
-
-                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    out.report.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          sourceMap));
-                }
+                checkResponse(node, pd, out);
             }
         }
 
@@ -421,7 +364,7 @@ namespace snowcrash {
         static bool parseSignature(const MarkdownNodeIterator& node,
                                    SectionParserData& pd,
                                    const mdp::ByteBuffer& signature,
-                                   ParseResult<Payload>& out) {
+                                   const ParseResultRef<Payload>& out) {
 
             const char* regex;
             mdp::ByteBuffer mediaType;
@@ -524,93 +467,195 @@ namespace snowcrash {
             return true;
         }
 
+        /** Given the reference id(name), initializes reference of the payload accordingly(if possible resolve it) */
         static bool parseSymbolReference(const MarkdownNodeIterator& node,
                                          SectionParserData& pd,
                                          mdp::ByteBuffer& source,
-                                         ParseResult<Payload>& out) {
+                                         const ParseResultRef<Payload>& out) {
 
-            SymbolName symbol;
-            ResourceModel model;
-            SourceMap<ResourceModel> modelSM;
+            Identifier symbol;
 
             TrimString(source);
 
             if (GetSymbolReference(source, symbol)) {
-                out.node.symbol = symbol;
+
+                out.node.reference.id = symbol;
+                out.node.reference.meta.node = node;
+                out.node.reference.type = Reference::SymbolReference;
 
                 if (pd.exportSourceMap() && !symbol.empty()) {
-                    out.sourceMap.symbol.sourceMap = node->sourceMap;
+                    out.sourceMap.reference.sourceMap = node->sourceMap;
                 }
 
-                // If symbol doesn't exist
+                // If symbol has not been defined yet in symbol table
                 if (pd.symbolTable.resourceModels.find(symbol) == pd.symbolTable.resourceModels.end()) {
 
-                    // ERR: Undefined symbol
-                    std::stringstream ss;
-                    ss << "Undefined symbol " << symbol;
-
-                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    out.report.error = Error(ss.str(), SymbolError, sourceMap);
+                    out.node.reference.meta.state = Reference::StatePending;
 
                     return true;
                 }
 
-                model = pd.symbolTable.resourceModels.at(symbol);
-                
-                out.node.description = model.description;
-                out.node.parameters = model.parameters;
-                
-                HeaderIterator modelContentType = std::find_if(model.headers.begin(),
-                                                               model.headers.end(),
-                                                               std::bind2nd(MatchFirstWith<Header, std::string>(),
-                                                                            HTTPHeaderName::ContentType));
-                
-                bool isPayloadContentType = !out.node.headers.empty();
-                bool isModelContentType = modelContentType != model.headers.end();
-                
-                if (isPayloadContentType && isModelContentType) {
-                    
-                    // WARN: Ignoring payload content-type, when referencing a model with headers
-                    std::stringstream ss;
-                    
-                    ss << "ignoring additional " << SectionName(pd.sectionContext()) << " header(s), ";
-                    ss << "specify this header(s) in the referenced model definition instead";
-                    
-                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    out.report.warnings.push_back(Warning(ss.str(),
-                                                          IgnoringWarning,
-                                                          sourceMap));
-                }
+                out.node.reference.meta.state = Reference::StateResolved;
+
+                assingReferredPayload(pd, out);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         *  \brief  Assigns the reference, referred as reference id(name), into the payload
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void assingReferredPayload(SectionParserData& pd,
+                                          const ParseResultRef<Payload>& out) {
+
+            SourceMap<ResourceModel> modelSM;
+            ResourceModel model = pd.symbolTable.resourceModels.at(out.node.reference.id);
+
+
+            out.node.description = model.description;
+            out.node.parameters = model.parameters;
+
+            HeaderIterator modelContentTypeIt = std::find_if(model.headers.begin(),
+                                                             model.headers.end(),
+                                                             std::bind2nd(MatchFirstWith<Header, std::string>(),
+                                                                          HTTPHeaderName::ContentType));
+
+            bool isPayloadContentType = !out.node.headers.empty();
+            bool isModelContentType = modelContentTypeIt != model.headers.end();
+
+            if (isPayloadContentType && isModelContentType) {
+
+                // WARN: Ignoring payload content-type, when referencing a model with headers
+                std::stringstream ss;
+
+                ss << "ignoring additional " << SectionName(pd.sectionContext()) << " header(s), ";
+                ss << "specify this header(s) in the referenced model definition instead";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(out.node.reference.meta.node->sourceMap, pd.sourceData);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      IgnoringWarning,
+                                                      sourceMap));
+            }
+
+            if (isPayloadContentType && !isModelContentType) {
+                out.node.headers.insert(out.node.headers.end(), model.headers.begin(), model.headers.end());
+            } else {
+                out.node.headers = model.headers;
+            }
+
+            out.node.body = model.body;
+            out.node.schema = model.schema;
+
+            if (pd.exportSourceMap()) {
+
+                modelSM = pd.symbolSourceMapTable.resourceModels.at(out.node.reference.id);
+
+                out.sourceMap.description = modelSM.description;
+                out.sourceMap.parameters = modelSM.parameters;
+                out.sourceMap.body = modelSM.body;
+                out.sourceMap.schema = modelSM.schema;
 
                 if (isPayloadContentType && !isModelContentType) {
-                    out.node.headers.insert(out.node.headers.end(), model.headers.begin(), model.headers.end());
+                    out.sourceMap.headers.collection.insert(out.sourceMap.headers.collection.end(), modelSM.headers.collection.begin(), modelSM.headers.collection.end());
                 } else {
-                    out.node.headers = model.headers;
+                    out.sourceMap.headers = modelSM.headers;
+                }
+            }
+        }
+
+        /**
+         *  \brief  Checks request given as out
+         *  \param  node     Markdown node
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void checkRequest(const MarkdownNodeIterator& node,
+                                 SectionParserData& pd,
+                                 const ParseResultRef<Payload>& out) {
+
+            bool warnEmptyBody = false;
+
+            mdp::ByteBuffer contentLength;
+            mdp::ByteBuffer transferEncoding;
+
+            for (HeaderIterator it = out.node.headers.begin();
+                 it != out.node.headers.end();
+                 ++it) {
+
+                if (it->first == HTTPHeaderName::ContentLength) {
+                    contentLength = it->second;
+                }
+
+                if (it->first == HTTPHeaderName::TransferEncoding) {
+                    transferEncoding = it->second;
                 }
-                
-                out.node.body = model.body;
-                out.node.schema = model.schema;
+            }
 
-                if (pd.exportSourceMap()) {
+            if (out.node.body.empty() && out.node.reference.meta.state != Reference::StatePending) {
 
-                    modelSM = pd.symbolSourceMapTable.resourceModels.at(symbol);
+                // Warn when content-length or transfer-encoding is specified or both headers and body are empty
+                if (out.node.headers.empty()) {
+                    warnEmptyBody = true;
+                } else {
+                    warnEmptyBody = !contentLength.empty() || !transferEncoding.empty();
+                }
 
-                    out.sourceMap.description = modelSM.description;
-                    out.sourceMap.parameters = modelSM.parameters;
-                    out.sourceMap.body = modelSM.body;
-                    out.sourceMap.schema = modelSM.schema;
+                if (warnEmptyBody) {
 
-                    if (isPayloadContentType && !isModelContentType) {
-                        out.sourceMap.headers.collection.insert(out.sourceMap.headers.collection.end(), modelSM.headers.collection.begin(), modelSM.headers.collection.end());
-                    } else {
-                        out.sourceMap.headers = modelSM.headers;
+                    // WARN: empty body
+                    std::stringstream ss;
+                    ss << "empty " << SectionName(RequestSectionType) << " " << SectionName(BodySectionType);
+
+                    if (!contentLength.empty()) {
+                        ss << ", expected " << SectionName(BodySectionType) << " for '" << contentLength << "' Content-Length";
+                    } else if (!transferEncoding.empty()) {
+                        ss << ", expected " << SectionName(BodySectionType) << " for '" << transferEncoding << "' Transfer-Encoding";
                     }
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          EmptyDefinitionWarning,
+                                                          sourceMap));
                 }
+            }
+        }
 
-                return true;
+        /**
+         *  \brief  Checks response given as out
+         *  \param  node     Markdown node
+         *  \param  pd       Section parser state
+         *  \param  out      Processed output
+         */
+        static void checkResponse(const MarkdownNodeIterator& node,
+                                  SectionParserData& pd,
+                                  const ParseResultRef<Payload>& out) {
+
+            HTTPStatusCode code = 200;
+
+            if (!out.node.name.empty()) {
+                std::stringstream(out.node.name) >> code;
             }
 
-            return false;
+            StatusCodeTraits statusCodeTraits = GetStatusCodeTrait(code);
+
+            if (!statusCodeTraits.allowBody &&
+                !out.node.body.empty() &&
+                out.node.reference.meta.state != Reference::StatePending) {
+
+                // WARN: not empty body
+                std::stringstream ss;
+                ss << "the " << code << " response MUST NOT include a " << SectionName(BodySectionType);
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
+            }
         }
 
         /**