redsnow 0.3.7 → 0.4.0

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

@@ -0,0 +1,75 @@
+//
+//  RelationParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 04/03/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_RELATIONPARSER_H
+#define SNOWCRASH_RELATIONPARSER_H
+
+#include "SectionParser.h"
+#include "RegexMatch.h"
+
+namespace snowcrash {
+
+    /** Link Relation matching regex */
+    const char* const RelationRegex = "^[[:blank:]]*[Rr]elation[[:blank:]]*:[[:blank:]]*([a-z][a-z0-9.-]*)?[[:blank:]]*$";
+
+    /**
+     *  Relation Section Processor
+     */
+    template<>
+    struct SectionProcessor<Relation> : public SectionProcessorBase<Relation> {
+
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     SectionParserData& pd,
+                                                     SectionLayout& layout,
+                                                     const ParseResultRef<Relation>& out) {
+
+            mdp::ByteBuffer signature, remainingContent;
+            CaptureGroups captureGroups;
+
+            signature = GetFirstLine(node->text, remainingContent);
+            TrimString(signature);
+
+            if (RegexCapture(signature, RelationRegex, captureGroups, 3)) {
+                out.node.str = captureGroups[1];
+                TrimString(out.node.str);
+            }
+
+            if (pd.exportSourceMap() && !out.node.str.empty()) {
+                out.sourceMap.sourceMap.append(node->sourceMap);
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        NO_SECTION_DESCRIPTION(Relation)
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                mdp::ByteBuffer remaining, subject = node->children().front().text;
+
+                subject = GetFirstLine(subject, remaining);
+                TrimString(subject);
+
+                if (RegexMatch(subject, RelationRegex)) {
+                    return RelationSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+    };
+
+    /** Relation Section Parser */
+    typedef SectionParser<Relation, ListSectionAdapter> RelationParser;
+}
+
+#endif

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

@@ -47,37 +47,72 @@ namespace snowcrash {
             CaptureGroups captureGroups;
 
             if (RegexCapture(node->text, GroupHeaderRegex, captureGroups, 3)) {
-                out.node.name = captureGroups[1];
-                TrimString(out.node.name);
+                out.node.attributes.name = captureGroups[1];
+                TrimString(out.node.attributes.name);
             }
 
-            if (pd.exportSourceMap() && !out.node.name.empty()) {
-                out.sourceMap.name.sourceMap = node->sourceMap;
+            if (pd.exportSourceMap() && !out.node.attributes.name.empty()) {
+                out.sourceMap.attributes.name.sourceMap = node->sourceMap;
             }
 
             return ++MarkdownNodeIterator(node);
         }
 
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<ResourceGroup>& out) {
+
+            // Check for a description child element
+            if (out.node.content.elements().empty() ||
+                (!out.node.content.elements().empty() &&
+                 out.node.content.elements().back().element != Element::CopyElement)) {
+
+                Element description(Element::CopyElement);
+                out.node.content.elements().push_back(description);
+
+                if (pd.exportSourceMap()) {
+
+                    SourceMap<Element> descriptionSM(Element::CopyElement);
+                    out.sourceMap.content.elements().collection.push_back(descriptionSM);
+                }
+            }
+
+            if (!out.node.content.elements().back().content.copy.empty()) {
+                TwoNewLines(out.node.content.elements().back().content.copy);
+            }
+
+            mdp::ByteBuffer content = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+
+            if (pd.exportSourceMap() && !content.empty()) {
+                out.sourceMap.content.elements().collection.back().content.copy.sourceMap.append(node->sourceMap);
+            }
+
+            out.node.content.elements().back().content.copy += content;
+
+            return ++MarkdownNodeIterator(node);
+        }
+
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
                                                          const ParseResultRef<ResourceGroup>& out) {
 
+            MarkdownNodeIterator cur = node;
+
             if (pd.sectionContext() == ResourceSectionType) {
 
                 IntermediateParseResult<Resource> resource(out.report);
+                cur = ResourceParser::parse(node, siblings, pd, resource);
 
-                MarkdownNodeIterator cur = ResourceParser::parse(node, siblings, pd, resource);
-
-                ResourceIterator duplicate = SectionProcessor<Resource>::findResource(out.node.resources, resource.node);
-                ResourceIteratorPair globalDuplicate;
+                bool duplicate = SectionProcessor<Resource>::isResourceDuplicate(out.node.content.elements(), resource.node.uriTemplate);
+                bool globalDuplicate;
 
-                if (duplicate == out.node.resources.end()) {
-                    globalDuplicate = findResource(pd.blueprint, resource.node);
+                if (!duplicate) {
+                    globalDuplicate = isResourceDuplicate(pd.blueprint, resource.node.uriTemplate);
                 }
 
-                if (duplicate != out.node.resources.end() ||
-                    globalDuplicate.first != pd.blueprint.resourceGroups.end()) {
+                if (duplicate || globalDuplicate) {
 
                     // WARN: Duplicate resource
                     mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
@@ -86,16 +121,21 @@ namespace snowcrash {
                                                           sourceMap));
                 }
 
-                out.node.resources.push_back(resource.node);
+                Element resourceElement(Element::ResourceElement);
+                resourceElement.content.resource = resource.node;
+
+                out.node.content.elements().push_back(resourceElement);
 
                 if (pd.exportSourceMap()) {
-                    out.sourceMap.resources.collection.push_back(resource.sourceMap);
-                }
 
-                return cur;
+                    SourceMap<Element> resourceElementSM(Element::ResourceElement);
+                    resourceElementSM.content.resource = resource.sourceMap;
+
+                    out.sourceMap.content.elements().collection.push_back(resourceElementSM);
+                }
             }
 
-            return node;
+            return cur;
         }
 
         static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
@@ -105,17 +145,16 @@ namespace snowcrash {
                                                           const ParseResultRef<ResourceGroup>& out) {
 
             if (SectionProcessor<Action>::actionType(node) == DependentActionType &&
-                !out.node.resources.empty()) {
+                isResourcePresent(out.node.content.elements())) {
 
-                mdp::ByteBuffer method;
-                mdp::ByteBuffer name;
+                mdp::ByteBuffer method, name, uriTemplate;
 
-                SectionProcessor<Action>::actionHTTPMethodAndName(node, method, name);
+                SectionProcessor<Action>::actionHTTPMethodAndName(node, method, name, uriTemplate);
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
 
                 // WARN: Unexpected action
                 std::stringstream ss;
-                ss << "unexpected action '" << method << "', to define multiple actions for the '" << out.node.resources.back().uriTemplate;
+                ss << "unexpected action '" << method << "', to define multiple actions for the '" << lastResource(out.node.content.elements()).uriTemplate;
                 ss << "' resource omit the HTTP method in its definition, e.g. '# /resource'";
 
                 out.report.warnings.push_back(Warning(ss.str(),
@@ -128,6 +167,20 @@ namespace snowcrash {
             return SectionProcessorBase<ResourceGroup>::processUnexpectedNode(node, siblings, pd, lastSectionType, out);
         }
 
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<ResourceGroup>& out) {
+
+            out.node.element = Element::CategoryElement;
+            out.node.category = Element::ResourceGroupCategory;
+
+            if (pd.exportSourceMap()) {
+
+                out.sourceMap.element = out.node.element;
+                out.sourceMap.category = out.node.category;
+            }
+        }
+
         static SectionType sectionType(const MarkdownNodeIterator& node) {
 
             if (node->type == mdp::HeaderMarkdownNodeType
@@ -183,22 +236,63 @@ namespace snowcrash {
             return SectionProcessorBase<ResourceGroup>::isUnexpectedNode(node, sectionType);
         }
 
-        /** Finds a resource in blueprint by its URI template */
-        static ResourceIteratorPair findResource(const Blueprint& blueprint,
-                                                 const Resource& resource) {
-
-            for (ResourceGroupIterator it = blueprint.resourceGroups.begin();
-                  it != blueprint.resourceGroups.end();
+        /**
+         * \brief Given a blueprint, Check if a resource already exists with the given uri template
+         *
+         * \param blueprint The blueprint which is formed until now
+         * \param uri The resource uri template to be checked
+         */
+        static bool isResourceDuplicate(const Blueprint& blueprint,
+                                        const URITemplate& uri) {
+
+            for (Elements::const_iterator it = blueprint.content.elements().begin();
+                  it != blueprint.content.elements().end();
                   ++it) {
 
-                ResourceIterator match = SectionProcessor<Resource>::findResource(it->resources, resource);
+                if (it->element == Element::CategoryElement &&
+                    SectionProcessor<Resource>::isResourceDuplicate(it->content.elements(), uri)) {
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /**
+         * \brief Given list of elements, return true if none of them is a resource element
+         *
+         * \param elements Collection of elements
+         */
+        static bool isResourcePresent(const Elements& elements) {
+
+            for (Elements::const_iterator it = elements.begin(); it != elements.end(); ++it) {
+
+                if (it->element == Element::ResourceElement) {
+                    return false;
+                }
+            }
 
-                if (match != it->resources.end()) {
-                    return std::make_pair(it, match);
+            return true;
+        }
+
+        /**
+         * \brief Given list of elements, get the last resource
+         *
+         * \param elements Collection fo elements
+         */
+        static Resource lastResource(const Elements& elements) {
+
+            Resource last;
+
+            for (Elements::const_iterator it = elements.begin(); it != elements.end(); ++it) {
+
+                if (it->element == Element::ResourceElement) {
+                    last = it->content.resource;
                 }
-             }
+            }
 
-             return std::make_pair(blueprint.resourceGroups.end(), ResourceIterator());
+            return last;
         }
     };
 

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

@@ -11,6 +11,7 @@
 
 #include "SectionParser.h"
 #include "ActionParser.h"
+#include "DataStructureGroupParser.h"
 #include "HeadersParser.h"
 #include "ParametersParser.h"
 #include "UriTemplateParser.h"
@@ -63,11 +64,8 @@ namespace snowcrash {
 
                     return cur;
                 }
-            } else if (RegexCapture(node->text, NamedResourceHeaderRegex, captureGroups, 4)) {
-
-                out.node.name = captureGroups[1];
-                TrimString(out.node.name);
-                out.node.uriTemplate = captureGroups[2];
+            } else {
+                matchNamedResourceHeader(node, out.node);
             }
 
             if (pd.exportSourceMap()) {
@@ -105,6 +103,40 @@ namespace snowcrash {
                     return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, headers);
                 }
 
+                case AttributesSectionType:
+                {
+                    ParseResultRef<Attributes> attributes(out.report, out.node.attributes, out.sourceMap.attributes);
+                    MarkdownNodeIterator cur = AttributesParser::parse(node, siblings, pd, attributes);
+
+                    if (!out.node.name.empty()) {
+
+                        if (SectionProcessor<DataStructureGroup>::isNamedTypeDuplicate(pd.blueprint, out.node.name)) {
+
+                            // WARN: duplicate named type
+                            std::stringstream ss;
+                            ss << "named type with name '" << out.node.name << "' already exists";
+
+                            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                            out.report.warnings.push_back(Warning(ss.str(),
+                                                                  DuplicateWarning,
+                                                                  sourceMap));
+
+                            // Remove the attributes data from the AST since we are ignoring this
+                            out.node.attributes = mson::NamedType();
+
+                            return cur;
+                        }
+
+                        attributes.node.name.symbol.literal = out.node.name;
+
+                        if (pd.exportSourceMap()) {
+                            attributes.sourceMap.name.sourceMap = out.sourceMap.name.sourceMap;
+                        }
+                    }
+
+                    return cur;
+                }
+
                 default:
                     break;
             }
@@ -129,14 +161,14 @@ namespace snowcrash {
                     out.sourceMap.model.body.sourceMap.append(node->sourceMap);
                 }
 
-                // Update model in the symbol table as well
-                ResourceModelSymbolTable::iterator it = pd.symbolTable.resourceModels.find(out.node.model.name);
+                // Update model in the model table as well
+                ModelTable::iterator it = pd.modelTable.find(out.node.model.name);
 
-                if (it != pd.symbolTable.resourceModels.end()) {
+                if (it != pd.modelTable.end()) {
                     it->second.body = out.node.model.body;
 
                     if (pd.exportSourceMap()) {
-                        pd.symbolSourceMapTable.resourceModels[out.node.model.name].body = out.sourceMap.model.body;
+                        pd.modelSourceMapTable[out.node.model.name].body = out.sourceMap.model.body;
                     }
                 }
 
@@ -189,7 +221,7 @@ namespace snowcrash {
             // Check if headers section
             nestedType = SectionProcessor<Headers>::sectionType(node);
 
-            if (nestedType == HeadersSectionType) {
+            if (nestedType != UndefinedSectionType) {
                 return nestedType;
             }
 
@@ -202,6 +234,13 @@ namespace snowcrash {
                 return nestedType;
             }
 
+            // Check if attributes section
+            nestedType = SectionProcessor<Attributes>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
             // Check if action section
             nestedType = SectionProcessor<Action>::sectionType(node);
 
@@ -252,14 +291,14 @@ namespace snowcrash {
             // Consolidate deprecated headers into subsequent payloads
             if (!out.node.headers.empty()) {
 
-                Collection<Action>::iterator actIt = out.node.actions.begin();
-                Collection<SourceMap<Action> >::iterator actSMIt = out.sourceMap.actions.collection.begin();
+                Collection<Action>::iterator actionIt = out.node.actions.begin();
+                Collection<SourceMap<Action> >::iterator actionSMIt = out.sourceMap.actions.collection.begin();
 
                 for (;
-                     actIt != out.node.actions.end();
-                     ++actIt, ++actSMIt) {
+                     actionIt != out.node.actions.end();
+                     ++actionIt, ++actionSMIt) {
 
-                    SectionProcessor<Headers>::injectDeprecatedHeaders(pd, out.node.headers, out.sourceMap.headers, actIt->examples, actSMIt->examples);
+                    SectionProcessor<Headers>::injectDeprecatedHeaders(pd, out.node.headers, out.sourceMap.headers, actionIt->examples, actionSMIt->examples);
                 }
 
                 out.node.headers.clear();
@@ -270,6 +309,25 @@ namespace snowcrash {
             }
         }
 
+        /**
+         * \brief Given a named resource header, retrieve the name and uriTemplate
+         *
+         * \param node Markdown node to process
+         * \param resource Resource data structure
+         */
+        static void matchNamedResourceHeader(const MarkdownNodeIterator& node,
+                                             Resource& resource) {
+
+            CaptureGroups captureGroups;
+
+            if (RegexCapture(node->text, NamedResourceHeaderRegex, captureGroups, 4)) {
+
+                resource.name = captureGroups[1];
+                TrimString(resource.name);
+                resource.uriTemplate = captureGroups[2];
+            }
+        }
+
         /** Process Action section */
         static MarkdownNodeIterator processAction(const MarkdownNodeIterator& node,
                                                   const MarkdownNodes& siblings,
@@ -277,7 +335,6 @@ namespace snowcrash {
                                                   const ParseResultRef<Resource>& out) {
 
             IntermediateParseResult<Action> action(out.report);
-
             MarkdownNodeIterator cur = ActionParser::parse(node, siblings, pd, action);
 
             ActionIterator duplicate = SectionProcessor<Action>::findAction(out.node.actions, action.node);
@@ -295,9 +352,28 @@ namespace snowcrash {
                                                       sourceMap));
             }
 
+            ActionIterator relationDuplicate = SectionProcessor<Action>::findRelation(out.node.actions, action.node.relation);
+
+            if (relationDuplicate != out.node.actions.end()) {
+
+                // WARN: duplicate relation identifier
+                std::stringstream ss;
+                ss << "relation identifier '" << action.node.relation.str << "' already defined for resource '" << out.node.uriTemplate << "'";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      DuplicateWarning,
+                                                      sourceMap));
+            }
+
             if (!action.node.parameters.empty()) {
 
-                checkParametersEligibility(node, pd, action.node.parameters, out);
+                if (!action.node.uriTemplate.empty()) {
+                    checkParametersEligibility<Action>(node, pd, action.node.parameters, action);
+                }
+                else {
+                    checkParametersEligibility<Resource>(node, pd, action.node.parameters, out);
+                }
             }
 
             out.node.actions.push_back(action.node);
@@ -321,7 +397,7 @@ namespace snowcrash {
 
             if (!parameters.node.empty()) {
 
-                checkParametersEligibility(node, pd, parameters.node, out);
+                checkParametersEligibility<Resource>(node, pd, parameters.node, out);
                 out.node.parameters.insert(out.node.parameters.end(), parameters.node.begin(), parameters.node.end());
 
                 if (pd.exportSourceMap()) {
@@ -382,29 +458,29 @@ namespace snowcrash {
 
                     mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                     out.report.error = Error(ss.str(),
-                                             SymbolError,
+                                             ModelError,
                                              sourceMap);
                 }
             }
 
-            ResourceModelSymbolTable::iterator it = pd.symbolTable.resourceModels.find(model.node.name);
+            ModelTable::iterator it = pd.modelTable.find(model.node.name);
 
-            if (it == pd.symbolTable.resourceModels.end()) {
+            if (it == pd.modelTable.end()) {
 
-                pd.symbolTable.resourceModels[model.node.name] = model.node;
+                pd.modelTable[model.node.name] = model.node;
 
                 if (pd.exportSourceMap()) {
-                    pd.symbolSourceMapTable.resourceModels[model.node.name] = model.sourceMap;
+                    pd.modelSourceMapTable[model.node.name] = model.sourceMap;
                 }
             } else {
 
-                // ERR: Symbol already defined
+                // ERR: Model already defined
                 std::stringstream ss;
                 ss << "symbol '" << model.node.name << "' already defined";
 
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                 out.report.error = Error(ss.str(),
-                                         SymbolError,
+                                         ModelError,
                                          sourceMap);
             }
 
@@ -417,11 +493,16 @@ namespace snowcrash {
             return cur;
         }
 
-        /** Check Parameters eligibility in URI template */
+        /**
+         * \brief Check Parameters eligibility in URI template
+         *
+         * \warning Do not specialise this.
+         */
+        template<typename T>
         static void checkParametersEligibility(const MarkdownNodeIterator& node,
                                                const SectionParserData& pd,
                                                Parameters& parameters,
-                                               const ParseResultRef<Resource>& out) {
+                                               const ParseResultRef<T>& out) {
 
             for (ParameterIterator it = parameters.begin();
                  it != parameters.end();
@@ -448,13 +529,25 @@ namespace snowcrash {
             }
         }
 
-        /** Finds a resource inside an resources collection */
-        static ResourceIterator findResource(const Resources& resources,
-                                             const Resource& resource) {
+        /**
+         * \brief Given a list of elements, Check if a resource already exists with the given uri template
+         *
+         * \param elements Collection of elements
+         * \param uri The resource uri template to be checked
+         */
+        static bool isResourceDuplicate(const Elements& elements,
+                                        const URITemplate& uri) {
+
+            for (Elements::const_iterator it = elements.begin(); it != elements.end(); ++it) {
+
+                if (it->element == Element::ResourceElement &&
+                    it->content.resource.uriTemplate == uri) {
+
+                    return true;
+                }
+            }
 
-            return std::find_if(resources.begin(),
-                                resources.end(),
-                                std::bind2nd(MatchResource(), resource));
+            return false;
         }
     };