redsnow 0.3.7 → 0.4.0

data/ext/{snowcrash → drafter/ext/snowcrash}/ext/markdown-parser/src/MarkdownParser.h

@@ -14,8 +14,16 @@
 #include "markdown.h"
 
 namespace mdp {
-    
-    /** 
+
+    const char* const MarkdownEmphasisChars = "*_";
+    const char* const MarkdownListItemChars = "+-*";
+
+    const char MarkdownBeginReference = '[';
+    const char MarkdownEndReference = ']';
+
+    const char* const MarkdownLinkRegex = "^[[:blank:]]*\\[(.*)][[:blank:]]*(\\[([^][()]*)]|\\(([^][()]+)\\))[[:blank:]]*$";
+
+    /**
      *  GitHub-flavored Markdown Parser
      */
     class MarkdownParser {

data/ext/{snowcrash → drafter/ext/snowcrash}/snowcrash.gyp

@@ -57,54 +57,62 @@
         'src',
         'ext/markdown-parser/src',
         'ext/markdown-parser/ext/sundown/src',
-        'ext/markdown-parser/ext/sundown/html'
+        'ext/markdown-parser/ext/sundown/html',
       ],
       'sources': [
-        'src/CBlueprint.cc',
-        'src/CBlueprint.h',
-        'src/CBlueprintSourcemap.cc',
-        'src/CBlueprintSourcemap.h',
-        'src/CSourceAnnotation.cc',
-        'src/CSourceAnnotation.h',
         'src/HTTP.cc',
         'src/HTTP.h',
+        'src/MSON.cc',
+        'src/MSONOneOfParser.cc',
+        'src/MSONSourcemap.cc',
+        'src/MSONTypeSectionParser.cc',
+        'src/MSONValueMemberParser.cc',
+        'src/Blueprint.cc',
+        'src/BlueprintSourcemap.cc',
         'src/Section.cc',
         'src/Section.h',
-        'src/Serialize.cc',
-        'src/Serialize.h',
-        'src/SerializeJSON.cc',
-        'src/SerializeJSON.h',
-        'src/SerializeYAML.cc',
-        'src/SerializeYAML.h',
         'src/Signature.cc',
         'src/Signature.h',
         'src/snowcrash.cc',
         'src/snowcrash.h',
-        'src/csnowcrash.cc',
-        'src/csnowcrash.h',
         'src/UriTemplateParser.cc',
         'src/UriTemplateParser.h',
         'src/PayloadParser.h',
         'src/SectionParserData.h',
         'src/ActionParser.h',
         'src/AssetParser.h',
+        'src/AttributesParser.h',
         'src/Blueprint.h',
         'src/BlueprintParser.h',
         'src/BlueprintSourcemap.h',
         'src/BlueprintUtility.h',
         'src/CodeBlockUtility.h',
+        'src/DataStructureGroupParser.h',
         'src/HeadersParser.h',
+        'src/HeadersParser.cc',
+        'src/ModelTable.h',
+        'src/MSON.h',
+        'src/MSONSourcemap.h',
+        'src/MSONMixinParser.h',
+        'src/MSONNamedTypeParser.h',
+        'src/MSONOneOfParser.h',
+        'src/MSONParameterParser.h',
+        'src/MSONPropertyMemberParser.h',
+        'src/MSONTypeSectionParser.h',
+        'src/MSONUtility.h',
+        'src/MSONValueMemberParser.h',
         'src/ParameterParser.h',
         'src/ParametersParser.h',
         'src/Platform.h',
         'src/RegexMatch.h',
+        'src/RelationParser.h',
         'src/ResourceGroupParser.h',
         'src/ResourceParser.h',
         'src/SectionParser.h',
         'src/SectionProcessor.h',
+        'src/SignatureSectionProcessor.h',
         'src/SourceAnnotation.h',
         'src/StringUtility.h',
-        'src/SymbolTable.h',
         'src/ValuesParser.h',
         'src/Version.h'
       ],
@@ -115,7 +123,7 @@
         ]
       ],
       'dependencies': [
-          'libmarkdownparser'
+          'libmarkdownparser',
       ]
     },
     {
@@ -132,23 +140,36 @@
       'sources': [
         'test/test-ActionParser.cc',
         'test/test-AssetParser.cc',
+        'test/test-AttributesParser.cc',
         'test/test-Blueprint.cc',
         'test/test-BlueprintParser.cc',
+        'test/test-BlueprintUtility.cc',
+        'test/test-DataStructureGroupParser.cc',
         'test/test-HeadersParser.cc',
         'test/test-Indentation.cc',
+        'test/test-ModelTable.cc',
+        'test/test-MSONMixinParser.cc',
+        'test/test-MSONNamedTypeParser.cc',
+        'test/test-MSONOneOfParser.cc',
+        'test/test-MSONParameterParser.cc',
+        'test/test-MSONPropertyMemberParser.cc',
+        'test/test-MSONTypeSectionParser.cc',
+        'test/test-MSONUtility.cc',
+        'test/test-MSONValueMemberParser.cc',
         'test/test-ParameterParser.cc',
         'test/test-ParametersParser.cc',
         'test/test-PayloadParser.cc',
         'test/test-RegexMatch.cc',
+        'test/test-RelationParser.cc',
         'test/test-ResourceParser.cc',
         'test/test-ResourceGroupParser.cc',
         'test/test-SectionParser.cc',
+        'test/test-Signature.cc',
+        'test/test-StringUtility.cc',
         'test/test-SymbolIdentifier.cc',
-        'test/test-SymbolTable.cc',
         'test/test-UriTemplateParser.cc',
         'test/test-ValuesParser.cc',
         'test/test-Warnings.cc',
-        'test/test-csnowcrash.cc',
         'test/test-snowcrash.cc'
       ],
       'dependencies': [
@@ -156,24 +177,6 @@
         'libmarkdownparser'
       ]
     },
-    {
-      'target_name': 'snowcrash',
-      'type': 'executable',
-      'include_dirs': [
-        'src',
-        'src/snowcrash',
-        'ext/markdown-parser/src',
-        'ext/markdown-parser/ext/sundown/src',
-        'ext/cmdline'
-      ],
-      'sources': [
-        'src/snowcrash/snowcrash.cc'
-      ],
-      'dependencies': [
-        'libsnowcrash',
-        'libmarkdownparser'
-      ]
-    },
     {
       'target_name': 'perf-libsnowcrash',
       'type': 'executable',
@@ -181,7 +184,6 @@
         'src',
         'ext/markdown-parser/src',
         'ext/markdown-parser/ext/sundown/src',
-        'ext/cmdline',
         'test',
         'test/performance',
       ],
@@ -190,7 +192,7 @@
       ],
       'dependencies': [
         'libsnowcrash',
-        'libmarkdownparser'
+        'libmarkdownparser',
       ]
     }
   ]

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

@@ -13,6 +13,7 @@
 #include "SectionParser.h"
 #include "ParametersParser.h"
 #include "PayloadParser.h"
+#include "RelationParser.h"
 #include "RegexMatch.h"
 
 namespace snowcrash {
@@ -21,7 +22,7 @@ namespace snowcrash {
     const char* const ActionHeaderRegex = "^[[:blank:]]*" HTTP_REQUEST_METHOD "[[:blank:]]*" URI_TEMPLATE "?$";
 
     /** Named action matching regex */
-    const char* const NamedActionHeaderRegex = "^[[:blank:]]*" SYMBOL_IDENTIFIER "\\[" HTTP_REQUEST_METHOD "]$";
+    const char* const NamedActionHeaderRegex = "^[[:blank:]]*" SYMBOL_IDENTIFIER "\\[" HTTP_REQUEST_METHOD "[[:blank:]]*" URI_TEMPLATE "?]$";
 
     /** Internal type alias for Collection iterator of Action */
     typedef Collection<Action>::const_iterator ActionIterator;
@@ -46,7 +47,7 @@ namespace snowcrash {
                                                      SectionLayout& layout,
                                                      const ParseResultRef<Action>& out) {
 
-            actionHTTPMethodAndName(node, out.node.method, out.node.name);
+            actionHTTPMethodAndName(node, out.node.method, out.node.name, out.node.uriTemplate);
             TrimString(out.node.name);
 
             mdp::ByteBuffer remainingContent;
@@ -60,6 +61,10 @@ namespace snowcrash {
                 if (!out.node.name.empty()) {
                     out.sourceMap.name.sourceMap = node->sourceMap;
                 }
+
+                if (!out.node.uriTemplate.empty()) {
+                    out.sourceMap.uriTemplate.sourceMap = node->sourceMap;
+                }
             }
 
             if (!remainingContent.empty()) {
@@ -85,6 +90,12 @@ namespace snowcrash {
             mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
 
             switch (sectionType) {
+                case RelationSectionType:
+                {
+                    ParseResultRef<Relation> relation(out.report, out.node.relation, out.sourceMap.relation);
+                    return RelationParser::parse(node, siblings, pd, relation);
+                }
+
                 case ParametersSectionType:
                 {
                     ParseResultRef<Parameters> parameters(out.report, out.node.parameters, out.sourceMap.parameters);
@@ -155,6 +166,12 @@ namespace snowcrash {
                     return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, headers);
                 }
 
+                case AttributesSectionType:
+                {
+                    ParseResultRef<Attributes> attributes(out.report, out.node.attributes, out.sourceMap.attributes);
+                    return AttributesParser::parse(node, siblings, pd, attributes);
+                }
+
                 default:
                     break;
             }
@@ -253,6 +270,13 @@ namespace snowcrash {
 
             SectionType nestedType = UndefinedSectionType;
 
+            // Check if relation section
+            nestedType = SectionProcessor<Relation>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
             // Check if parameters section
             nestedType = SectionProcessor<Parameters>::sectionType(node);
 
@@ -263,7 +287,14 @@ namespace snowcrash {
             // Check if headers section
             nestedType = SectionProcessor<Headers>::sectionType(node);
 
-            if (nestedType == HeadersSectionType) {
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
+            // Check if attributes section
+            nestedType = SectionProcessor<Attributes>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
                 return nestedType;
             }
 
@@ -285,6 +316,7 @@ namespace snowcrash {
             nested.push_back(ResponseSectionType);
             nested.push_back(RequestBodySectionType);
             nested.push_back(RequestSectionType);
+            nested.push_back(RelationSectionType);
 
             types = SectionProcessor<Payload>::nestedSectionTypes();
             nested.insert(nested.end(), types.begin(), types.end());
@@ -450,6 +482,7 @@ namespace snowcrash {
             }
 
             CaptureGroups captureGroups;
+
             if (RegexCapture(subject, ActionHeaderRegex, captureGroups, 3)) {
 
                 if (captureGroups[2].empty()) {
@@ -466,7 +499,8 @@ namespace snowcrash {
         /** \return HTTP request method and name of an action */
         static void actionHTTPMethodAndName(const MarkdownNodeIterator& node,
                                             mdp::ByteBuffer& method,
-                                            mdp::ByteBuffer& name) {
+                                            mdp::ByteBuffer& name,
+                                            mdp::ByteBuffer& uriTemplate) {
 
             CaptureGroups captureGroups;
             mdp::ByteBuffer subject, remaining;
@@ -476,9 +510,10 @@ namespace snowcrash {
 
             if (RegexCapture(subject, ActionHeaderRegex, captureGroups, 3)) {
                 method = captureGroups[1];
-            } else if (RegexCapture(subject, NamedActionHeaderRegex, captureGroups, 3)) {
+            } else if (RegexCapture(subject, NamedActionHeaderRegex, captureGroups, 4)) {
                 name = captureGroups[1];
                 method = captureGroups[2];
+                uriTemplate = captureGroups[3];
             }
 
             return;
@@ -490,7 +525,16 @@ namespace snowcrash {
 
             return std::find_if(actions.begin(),
                                 actions.end(),
-                                std::bind2nd(MatchAction<Action>(), action));
+                                std::bind2nd(MatchAction(), action));
+        }
+
+        /** Finds a relation identifier inside an actions collection */
+        static ActionIterator findRelation(const Actions& actions,
+                                           const Relation& relation) {
+
+            return std::find_if(actions.begin(),
+                                actions.end(),
+                                std::bind2nd(MatchRelation(), relation));
         }
     };
 

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

@@ -52,13 +52,7 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
-                                                       const MarkdownNodes& siblings,
-                                                       SectionParserData& pd,
-                                                       const ParseResultRef<Asset>& out) {
-
-            return node;
-        }
+        NO_SECTION_DESCRIPTION(Asset)
 
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
@@ -77,11 +71,6 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
-        static bool isDescriptionNode(const MarkdownNodeIterator& node,
-                                      SectionType sectionType) {
-            return false;
-        }
-
         static bool isContentNode(const MarkdownNodeIterator& node,
                                   SectionType sectionType) {
 

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

@@ -0,0 +1,121 @@
+//
+//  AttributesParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/25/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_ATTRIBUTESPARSER_H
+#define SNOWCRASH_ATTRIBUTESPARSER_H
+
+#include "RegexMatch.h"
+#include "MSONValueMemberParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** Attributes matching regex */
+    const char* const AttributesRegex = "^[[:blank:]]*[Aa]ttributes?[[:blank:]]*(\\(.*\\))?$";
+
+    /**
+     * Attributes section processor
+     */
+    template<>
+    struct SectionProcessor<Attributes> : public SignatureSectionProcessorBase<Attributes> {
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait |
+                                            SignatureTraits::AttributesTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<Attributes>& out) {
+
+            if (!IEqual<std::string>()(signature.identifier, "Attribute") &&
+                !IEqual<std::string>()(signature.identifier, "Attributes")) {
+
+                return node;
+            }
+
+            mson::parseTypeDefinition(node, pd, signature.attributes, out.report, out.node.typeDefinition);
+
+            if (pd.exportSourceMap()) {
+
+                if (!out.node.typeDefinition.empty()) {
+                    out.sourceMap.typeDefinition.sourceMap = node->sourceMap;
+                }
+            }
+
+            // Default to `object` type specification
+            if (out.node.typeDefinition.baseType == mson::UndefinedBaseType) {
+                out.node.typeDefinition.baseType = mson::ImplicitObjectBaseType;
+            }
+
+            SectionProcessor<mson::ValueMember>::parseRemainingContent(node, pd, signature.remainingContent,
+                                                                       out.node.sections, out.sourceMap.sections);
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<Attributes>& out) {
+
+            return SectionProcessor<mson::ValueMember>::blockDescription(node, pd, out.node.sections, out.sourceMap.sections);
+        }
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<Attributes>& out) {
+
+            ParseResultRef<mson::TypeSections> typeSections(out.report, out.node.sections, out.sourceMap.sections);
+
+            return SectionProcessor<mson::ValueMember>
+                    ::processNestedMembers<MSONTypeSectionListParser>(node, siblings, pd, typeSections,
+                                                                      out.node.typeDefinition.baseType);
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            return SectionProcessor<mson::ValueMember>::isDescriptionNode(node, sectionType);
+        }
+
+        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, AttributesRegex)) {
+                    return AttributesSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            return SectionProcessor<mson::ValueMember>::nestedSectionType(node);
+        }
+    };
+
+    /** Attributes Section Parser */
+    typedef SectionParser<Attributes, ListSectionAdapter> AttributesParser;
+}
+
+#endif