redsnow 0.3.7 → 0.4.0

data/ext/drafter/ext/snowcrash/src/ModelTable.h

@@ -0,0 +1,87 @@
+//
+//  ModelTable.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 6/9/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MODELTABLE_H
+#define SNOWCRASH_MODELTABLE_H
+
+#include <string>
+#include <map>
+#include "ByteBuffer.h"
+#include "RegexMatch.h"
+
+#ifdef DEBUG
+#include <iostream>
+#endif
+
+#include "BlueprintSourcemap.h"
+#include "StringUtility.h"
+
+// Symbol identifier regex
+#define SYMBOL_IDENTIFIER "([^][()]+)"
+
+namespace snowcrash {
+
+    /** Symbol reference matching regex */
+    const char* const ModelReferenceRegex("^[[:blank:]]*\\[" SYMBOL_IDENTIFIER "]\\[][[:blank:]]*$");
+
+    // Resource Object Model Table
+    typedef std::map<Identifier, ResourceModel> ModelTable;
+
+    // Resource Object Model Table source map
+    typedef std::map<Identifier, SourceMap<ResourceModel> > ModelSourceMapTable;
+
+    // Checks whether given source data represents reference to a symbol returning true if so,
+    // false otherwise. If source data is represent reference referred symbol name is filled in.
+    inline bool GetModelReference(const mdp::ByteBuffer& sourceData,
+                                   Identifier& referredModel) {
+
+        CaptureGroups captureGroups;
+
+        if (RegexCapture(sourceData, ModelReferenceRegex, captureGroups, 3)) {
+            referredModel = captureGroups[1];
+            TrimString(referredModel);
+            return true;
+        }
+
+        return false;
+    }
+
+#ifdef DEBUG
+    // Escape new lines
+    inline std::string EscapeNewlines(const std::string &input) {
+
+        size_t pos = 0;
+        std::string target(input);
+
+        while ((pos = target.find("\n", pos)) != std::string::npos) {
+            target.replace(pos, 1, "\\n");
+            pos += 2;
+        }
+
+        return target;
+    }
+
+    // Prints markdown block recursively to stdout
+    inline void PrintModelTable(const ModelTable& modelTable) {
+
+        std::cout << "Resource Model Symbols:\n";
+
+        for (ModelTable::const_iterator it = modelTable.begin();
+             it != modelTable.end();
+             ++it) {
+
+            std::cout << "- " << it->first << " - body: '" << EscapeNewlines(it->second.body) << "'\n";
+        }
+
+        std::cout << std::endl;
+    }
+#endif
+
+}
+
+#endif

data/ext/{snowcrash → drafter/ext/snowcrash}/src/ParameterParser.h

@@ -49,6 +49,14 @@ namespace snowcrash {
     /** Parameter description delimiter */
     const std::string DescriptionIdentifier = "...";
 
+    /** Parameter Definition Type */
+    enum ParameterType {
+        NotParameterType = 0,
+        OldParameterType,        /// Parameter defined using the old syntax
+        NewParameterType,        /// Parameter defined using the new MSON-like syntax
+        UndefinedParameterType = -1
+    };
+
     /**
      * Parameter section processor
      */
@@ -124,7 +132,7 @@ namespace snowcrash {
             if ((!out.node.exampleValue.empty() || !out.node.defaultValue.empty()) &&
                  !out.node.values.empty()) {
 
-                checkExampleAndDefaultValue(node, pd, out);
+                checkExampleAndDefaultValue<Parameter>(node, pd, out);
             }
 
             return ++MarkdownNodeIterator(node);
@@ -139,9 +147,15 @@ namespace snowcrash {
                 subject = GetFirstLine(node->children().front().text, remainingContent);
                 TrimString(subject);
 
-                if (isValidParameterSignature(subject)) {
+                ParameterType parameterType = getParameterType(subject);
+
+                if (parameterType == OldParameterType) {
                     return ParameterSectionType;
                 }
+
+                if (parameterType == NewParameterType) {
+                    return MSONParameterSectionType;
+                }
             }
 
             return UndefinedSectionType;
@@ -166,12 +180,9 @@ namespace snowcrash {
                                    const ParseResultRef<Parameter>& out) {
 
             out.node.use = UndefinedParameterUse;
-
             TrimString(signature);
 
-            CaptureGroups captureGroups;
-
-            if (isValidParameterSignature(signature)) {
+            if (pd.sectionContext() == ParameterSectionType) {
 
                 mdp::ByteBuffer innerSignature = signature;
                 innerSignature = TrimString(innerSignature);
@@ -238,21 +249,9 @@ namespace snowcrash {
                     }
                 }
 
-                // Check possible required vs default clash
-                if (out.node.use != OptionalParameterUse &&
-                    !out.node.defaultValue.empty()) {
-
-                    // WARN: Required vs default clash
-                    std::stringstream ss;
-                    ss << "specifying parameter '" << out.node.name << "' as required supersedes its default value"\
-                          ", declare the parameter as 'optional' to specify its default value";
-
-                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                    out.report.warnings.push_back(Warning(ss.str(),
-                                                          LogicalErrorWarning,
-                                                          sourceMap));
-                }
-            } else {
+                checkDefaultAndRequiredClash<Parameter>(node, pd, out);
+            }
+            else {
                 // ERR: unable to parse
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                 out.report.error = Error("unable to parse parameter specification",
@@ -349,9 +348,31 @@ namespace snowcrash {
             }
         }
 
+        template<typename T>
+        static void checkDefaultAndRequiredClash(const mdp::MarkdownNodeIterator& node,
+                                                 SectionParserData& pd,
+                                                 const ParseResultRef<T>& out) {
+
+            // Check possible required vs default clash
+            if (out.node.use != OptionalParameterUse &&
+                !out.node.defaultValue.empty()) {
+
+                // WARN: Required vs default clash
+                std::stringstream ss;
+                ss << "specifying parameter '" << out.node.name << "' as required supersedes its default value"\
+                ", declare the parameter as 'optional' to specify its default value";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      LogicalErrorWarning,
+                                                      sourceMap));
+            }
+        }
+
+        template<typename T>
         static void checkExampleAndDefaultValue(const mdp::MarkdownNodeIterator& node,
                                                 SectionParserData& pd,
-                                                const ParseResultRef<Parameter>& out) {
+                                                const ParseResultRef<T>& out) {
 
             bool isExampleFound = false;
             bool isDefaultFound = false;
@@ -396,72 +417,110 @@ namespace snowcrash {
             }
         }
 
-        /** Determine if a signature is a valid parameter*/
-        static bool isValidParameterSignature(const mdp::ByteBuffer& signature) {
+        /**
+         * \brief Determine the type of parameter using the signature
+         */
+        static ParameterType getParameterType(const mdp::ByteBuffer& signature) {
 
             mdp::ByteBuffer innerSignature = signature;
-            innerSignature = TrimString(innerSignature);
+            CaptureGroups captureGroups;
+
+            TrimString(innerSignature);
 
-            if (innerSignature.length() == 0) {
-                return false; // Empty string, invalid
+            if (innerSignature.empty()) {
+                return NotParameterType; // Empty string, invalid
             }
 
-            size_t firstSpace = innerSignature.find(" ");
+            if (RegexCapture(innerSignature, "^" PARAMETER_IDENTIFIER "[[:blank:]]*:?", captureGroups) &&
+                !captureGroups[0].empty()) {
 
-            if (firstSpace == std::string::npos) {
-                return RegexMatch(innerSignature, "^" PARAMETER_IDENTIFIER "$");
-            }
+                innerSignature = innerSignature.substr(captureGroups[0].size());
+
+                // If last char is ':', don't strip it from signature
+                if (captureGroups[0].substr(captureGroups[0].size() - 1) == ":") {
+                    innerSignature = ":" + innerSignature;
+                }
 
-            std::string paramName = innerSignature.substr(0, firstSpace);
+                TrimString(innerSignature);
+            }
+            else {
+                return NotParameterType;
+            }
 
-            if (!RegexMatch(paramName, "^" PARAMETER_IDENTIFIER "$")) {
-                return false; // Invalid param name
+            // If contains only parameter name
+            if (innerSignature.empty()) {
+                return OldParameterType;
             }
 
-            // Remove param name
-            innerSignature = innerSignature.substr(firstSpace + 1);
-            size_t descriptionPos = innerSignature.find(snowcrash::DescriptionIdentifier);
+            std::string firstChar = innerSignature.substr(0, 1);
 
-            // Remove description
-            if (descriptionPos != std::string::npos) {
-                innerSignature = innerSignature.substr(0, descriptionPos);
-                innerSignature = TrimString(innerSignature);
+            // If first char is ':' or `=`
+            if (firstChar == ":" || firstChar == "=") {
+
+                innerSignature = innerSignature.substr(1);
+                TrimString(innerSignature);
+
+                if (innerSignature.empty()) {
+                    return NotParameterType; // No sample or default value
+                }
+
+                // Traverse over the value
+                while (!innerSignature.empty()) {
+
+                    std::string first = innerSignature.substr(0, 1);
+
+                    if (first == "`") {
+                        RetrieveEscaped(innerSignature);
+                        TrimString(innerSignature);
+                    }
+                    else if (first == "(") {
+                        break;
+                    }
+                    else {
+                        innerSignature = innerSignature.substr(1);
+                    }
+                }
+
+                return firstChar == ":" ? NewParameterType : OldParameterType;
             }
 
-            size_t attributesPos = innerSignature.find("(");
+            if (innerSignature.substr(0, 1) == "(") {
 
-            if (attributesPos != std::string::npos) {
+                // We should use `matchBrackets` if the parameters are supported to be more complex
                 size_t endOfAttributesPos = innerSignature.find_last_of(")");
 
                 if (endOfAttributesPos == std::string::npos) {
-                    return false; // Expecting close of attributes
+                    return NotParameterType; // Expecting close of attributes
                 }
 
-                // Remove attributes
-                innerSignature = innerSignature.substr(0, attributesPos);
-                innerSignature = TrimString(innerSignature);
-            }
+                std::string attributes = innerSignature.substr(1, endOfAttributesPos);
 
-            if (innerSignature.length() == 0) {
-                return true;
-            }
-
-            if (innerSignature.substr(0,1) == "=") {
-                innerSignature = innerSignature.substr(1);
-                innerSignature = TrimString(innerSignature);
+                if (RegexMatch(attributes, "enum\\[[^][]+]")) {
+                    return NewParameterType;
+                }
 
-                if (innerSignature.length() == 0) {
-                    return false; // No default value
+                if (RegexMatch(attributes, "`")) {
+                    return OldParameterType;
                 }
 
-                if (innerSignature.substr(0,1) == "`" && innerSignature.substr(innerSignature.length()-1,1) == "`") {
-                    return true;
+                innerSignature = innerSignature.substr(endOfAttributesPos + 1);
+                TrimString(innerSignature);
+
+                if (innerSignature.empty()) {
+                    return OldParameterType;
                 }
             }
 
-            return false;
-        }
+            if (innerSignature.substr(0, 1) == "-") {
+                return NewParameterType;
+            }
 
+            if (innerSignature.substr(0, 3) == "...") {
+                return OldParameterType;
+            }
+
+            return NotParameterType;
+        }
     };
 
     /** Parameter Section Parser */

data/ext/{snowcrash → drafter/ext/snowcrash}/src/ParametersParser.h

@@ -11,6 +11,7 @@
 
 #include "SectionParser.h"
 #include "ParameterParser.h"
+#include "MSONParameterParser.h"
 #include "RegexMatch.h"
 #include "StringUtility.h"
 #include "BlueprintUtility.h"
@@ -58,26 +59,30 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
-                                                       const MarkdownNodes& siblings,
-                                                       SectionParserData& pd,
-                                                       const ParseResultRef<Parameters>& out) {
-
-            return node;
-        }
+        NO_SECTION_DESCRIPTION(Parameters)
 
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
                                                          const ParseResultRef<Parameters>& out) {
 
-            if (pd.sectionContext() != ParameterSectionType) {
-                return node;
-            }
-
             IntermediateParseResult<Parameter> parameter(out.report);
+            IntermediateParseResult<MSONParameter> msonParameter(out.report);
 
-            ParameterParser::parse(node, siblings, pd, parameter);
+            if (pd.sectionContext() == ParameterSectionType) {
+                ParameterParser::parse(node, siblings, pd, parameter);
+            }
+            else if (pd.sectionContext() == MSONParameterSectionType) {
+                MSONParameterParser::parse(node, siblings, pd, msonParameter);
+
+                // Copy values from MSON Parameter to normal parameter
+                parameter.report = msonParameter.report;
+                parameter.node = msonParameter.node;
+                parameter.sourceMap = msonParameter.sourceMap;
+            }
+            else {
+                return node;
+            }
 
             if (!out.node.empty()) {
 
@@ -105,12 +110,6 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static bool isDescriptionNode(const MarkdownNodeIterator& node,
-                                      SectionType sectionType) {
-
-            return false;
-        }
-
         static SectionType sectionType(const MarkdownNodeIterator& node) {
 
             if (node->type == mdp::ListItemMarkdownNodeType

data/ext/{snowcrash → drafter/ext/snowcrash}/src/PayloadParser.h

@@ -14,6 +14,7 @@
 #include "AssetParser.h"
 #include "HeadersParser.h"
 #include "ParametersParser.h"
+#include "AttributesParser.h"
 
 /** Media type in brackets regex */
 #define MEDIA_TYPE "([[:blank:]]*\\(([^\\)]*)\\))"
@@ -77,7 +78,7 @@ namespace snowcrash {
                     if (pd.exportSourceMap() && !out.node.description.empty()) {
                         out.sourceMap.description.sourceMap.append(node->sourceMap);
                     }
-                } else if (!parseSymbolReference(node, pd, remainingContent, out)) {
+                } else if (!parseModelReference(node, pd, remainingContent, out)) {
 
                     // NOTE: NOT THE CORRECT WAY TO DO THIS
                     // https://github.com/apiaryio/snowcrash/commit/a7c5868e62df0048a85e2f9aeeb42c3b3e0a2f07#commitcomment-7322085
@@ -102,11 +103,11 @@ namespace snowcrash {
             mdp::ByteBuffer content;
 
             if (!out.node.reference.id.empty()) {
-                //WARN: ignoring extraneous content after symbol reference
+                //WARN: ignoring extraneous content after model reference
                 std::stringstream ss;
 
-                ss << "ignoring extraneous content after symbol reference";
-                ss << ", expected symbol reference only e.g. '[" << out.node.reference.id << "][]'";
+                ss << "ignoring extraneous content after model reference";
+                ss << ", expected model 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(),
@@ -116,7 +117,7 @@ namespace snowcrash {
 
                 if (!out.node.body.empty() ||
                     node->type != mdp::ParagraphMarkdownNodeType ||
-                    !parseSymbolReference(node, pd, node->text, out)) {
+                    !parseModelReference(node, pd, node->text, out)) {
 
                     // NOTE: NOT THE CORRECT WAY TO DO THIS
                     // https://github.com/apiaryio/snowcrash/commit/a7c5868e62df0048a85e2f9aeeb42c3b3e0a2f07#commitcomment-7322085
@@ -147,6 +148,12 @@ namespace snowcrash {
                     return HeadersParser::parse(node, siblings, pd, headers);
                 }
 
+                case AttributesSectionType:
+                {
+                    ParseResultRef<Attributes> attributes(out.report, out.node.attributes, out.sourceMap.attributes);
+                    return AttributesParser::parse(node, siblings, pd, attributes);
+                }
+
                 case BodySectionType:
                 {
                     if (!out.node.body.empty()) {
@@ -276,6 +283,13 @@ namespace snowcrash {
                 return nestedType;
             }
 
+            // Check if attributes section
+            nestedType = SectionProcessor<Attributes>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
             return UndefinedSectionType;
         }
 
@@ -285,6 +299,7 @@ namespace snowcrash {
             nested.push_back(HeadersSectionType);
             nested.push_back(BodySectionType);
             nested.push_back(SchemaSectionType);
+            nested.push_back(AttributesSectionType);
 
             // Parameters & descendants
             nested.push_back(ParametersSectionType);
@@ -303,7 +318,8 @@ namespace snowcrash {
             if (sectionType == RequestSectionType || sectionType == RequestBodySectionType) {
 
                 checkRequest(node, pd, out);
-            } else if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
+            }
+            else if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
 
                 checkResponse(node, pd, out);
             }
@@ -467,28 +483,28 @@ 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,
-                                         const ParseResultRef<Payload>& out) {
+        /** Given the reference id(name), initializes reference of the payload accordingly (if possible resolve it) */
+        static bool parseModelReference(const MarkdownNodeIterator& node,
+                                        SectionParserData& pd,
+                                        mdp::ByteBuffer& source,
+                                        const ParseResultRef<Payload>& out) {
 
             Identifier symbol;
 
             TrimString(source);
 
-            if (GetSymbolReference(source, symbol)) {
+            if (GetModelReference(source, symbol)) {
 
                 out.node.reference.id = symbol;
                 out.node.reference.meta.node = node;
-                out.node.reference.type = Reference::SymbolReference;
+                out.node.reference.type = Reference::ModelReference;
 
                 if (pd.exportSourceMap() && !symbol.empty()) {
                     out.sourceMap.reference.sourceMap = node->sourceMap;
                 }
 
-                // If symbol has not been defined yet in symbol table
-                if (pd.symbolTable.resourceModels.find(symbol) == pd.symbolTable.resourceModels.end()) {
+                // If model has not been defined yet in model table
+                if (pd.modelTable.find(symbol) == pd.modelTable.end()) {
 
                     out.node.reference.meta.state = Reference::StatePending;
 
@@ -514,7 +530,7 @@ namespace snowcrash {
                                           const ParseResultRef<Payload>& out) {
 
             SourceMap<ResourceModel> modelSM;
-            ResourceModel model = pd.symbolTable.resourceModels.at(out.node.reference.id);
+            ResourceModel model = pd.modelTable.find(out.node.reference.id)->second;
 
 
             out.node.description = model.description;
@@ -553,7 +569,7 @@ namespace snowcrash {
 
             if (pd.exportSourceMap()) {
 
-                modelSM = pd.symbolSourceMapTable.resourceModels.at(out.node.reference.id);
+                modelSM = pd.modelSourceMapTable.at(out.node.reference.id);
 
                 out.sourceMap.description = modelSM.description;
                 out.sourceMap.parameters = modelSM.parameters;
@@ -596,7 +612,9 @@ namespace snowcrash {
                 }
             }
 
-            if (out.node.body.empty() && out.node.reference.meta.state != Reference::StatePending) {
+
+            if (out.node.body.empty() && out.node.attributes.empty() &&
+                out.node.reference.meta.state != Reference::StatePending) {
 
                 // Warn when content-length or transfer-encoding is specified or both headers and body are empty
                 if (out.node.headers.empty()) {