redsnow 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a54dde4bcbcf36bbd37d5f863e51b16bb247232a
-  data.tar.gz: 79fecb4a236ff45e54942a3da1f871088f9aba6c
+  metadata.gz: ee23a2d43da39feb6ca4e0238652fb4ab3233975
+  data.tar.gz: b9f182cffddcd81c49b515c8b033f4d84f7a3f64
 SHA512:
-  metadata.gz: 9854dd4d2376d9fe8edc14791390d86a60ec973790809400c21820cf429f6fa9e08b81e13bbe1b9e21c17a7308d105d8b68f70f5d8763a6ba3ddf734bacd5657
-  data.tar.gz: bc9ed83bc8b1e0fe7a339b7c282c08740254d75490c92ec4a05e48b00134490f5b90ce095e8715ce96a2780fac71cd557463a09be7380fc83b3b51ac2e31b416
+  metadata.gz: 0d6f68de2038028753baffa195aeea9e85d4cf020a3013a330259ca467009b1af0423642bd2464278198a50002edaae6752c8a16d78fe0a431f23fbfb819f848
+  data.tar.gz: dc19e0bee08bb8dfc73433a916c2155674ffd048ac231d38aebb4a947e8ab66619f1178659ccc9ebddff4b5428dd45101985f4a91d45379bd36a710e6986c05f

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
+- 0.2.1
+    - Support for source maps [Snow Crash v0.15.0](https://github.com/apiaryio/snowcrash/releases/tag/v0.15.0) and [AST Serialization Format 2.1](https://github.com/apiaryio/api-blueprint-ast/releases/tag/v2.1).
 - 0.2.0
-    - New Parser Architecture [Snow Crash v0.14.0](https://github.com/apiaryio/snowcrash/releases)
+    - New Parser Architecture [Snow Crash v0.14.0](https://github.com/apiaryio/snowcrash/releases/tag/v0.14.0)
 - 0.1.6
     - Fixing problem with submodules in Gem install [IS#25](https://github.com/apiaryio/redsnow/issues/25)
 - 0.1.5

data/README.md

@@ -24,6 +24,18 @@ result = RedSnow::parse('# My API')
 puts result.ast.name
 ```
 
+## Parsing options
+
+Options can be number or hash. We support `:requireBlueprintName` and `:exportSourcemap` option.
+
+```ruby
+require 'redsnow'
+
+result = RedSnow::parse('# My API', { :exportSourcemap => true })
+puts result.ast.name
+puts result.sourcemap.name
+```
+
 ## Hacking Redsnow
 You are welcome to contribute. Use following steps to build & test Redsnow.
 

data/ext/snowcrash/ext/markdown-parser/ext/sundown/src/markdown.c

@@ -2622,9 +2622,12 @@ sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, str
 		beg += 3;
 
 	while (beg < doc_size) /* iterating over lines */
-		if (is_ref(document, beg, doc_size, &end, md->refs))
+		if (is_ref(document, beg, doc_size, &end, md->refs)) {
+			if (end > beg)
+				expand_tabs(text, document + beg, end - beg);
+
 			beg = end;
-		else { /* skipping to the next line */
+		} else { /* skipping to the next line */
 			end = beg;
 			while (end < doc_size && document[end] != '\n' && document[end] != '\r')
 				end++;

data/ext/snowcrash/snowcrash.gyp

@@ -62,6 +62,8 @@
       'sources': [
         'src/CBlueprint.cc',
         'src/CBlueprint.h',
+        'src/CBlueprintSourcemap.cc',
+        'src/CBlueprintSourcemap.h',
         'src/CSourceAnnotation.cc',
         'src/CSourceAnnotation.h',
         'src/HTTP.cc',
@@ -88,6 +90,7 @@
         'src/AssetParser.h',
         'src/Blueprint.h',
         'src/BlueprintParser.h',
+        'src/BlueprintSourcemap.h',
         'src/BlueprintUtility.h',
         'src/CodeBlockUtility.h',
         'src/HeadersParser.h',
@@ -160,7 +163,8 @@
         'src',
         'src/snowcrash',
         'ext/markdown-parser/src',
-        'cmdline'
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/cmdline'
       ],
       'sources': [
         'src/snowcrash/snowcrash.cc'
@@ -176,7 +180,8 @@
       'include_dirs': [
         'src',
         'ext/markdown-parser/src',
-        'cmdline',
+        'ext/markdown-parser/ext/sundown/src',
+        'ext/cmdline',
         'test',
         'test/performance',
       ],

data/ext/snowcrash/src/ActionParser.h

@@ -23,9 +23,7 @@ namespace snowcrash {
     /** Named action matching regex */
     const char* const NamedActionHeaderRegex = "^[[:blank:]]*" SYMBOL_IDENTIFIER "\\[" HTTP_REQUEST_METHOD "]$";
 
-    /** Internal type alias for Collection of Action */
-    typedef Collection<Action>::type Actions;
-
+    /** Internal type alias for Collection iterator of Action */
     typedef Collection<Action>::const_iterator ActionIterator;
     
     /** Action Definition Type */
@@ -46,17 +44,30 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     Report& report,
-                                                     Action& out) {
+                                                     ParseResult<Action>& out) {
 
-            actionHTTPMethodAndName(node, out.method, out.name);
-            TrimString(out.name);
+            actionHTTPMethodAndName(node, out.node.method, out.node.name);
+            TrimString(out.node.name);
 
             mdp::ByteBuffer remainingContent;
             GetFirstLine(node->text, remainingContent);
 
+            if (pd.exportSourceMap()) {
+                if (!out.node.method.empty()) {
+                    out.sourceMap.method.sourceMap = node->sourceMap;
+                }
+
+                if (!out.node.name.empty()) {
+                    out.sourceMap.name.sourceMap = node->sourceMap;
+                }
+            }
+
             if (!remainingContent.empty()) {
-                out.description += remainingContent;
+                out.node.description += remainingContent;
+
+                if (pd.exportSourceMap()) {
+                    out.sourceMap.description.sourceMap.append(node->sourceMap);
+                }
             }
 
             return ++MarkdownNodeIterator(node);
@@ -65,50 +76,82 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         Report& report,
-                                                         Action& out) {
+                                                         ParseResult<Action>& out) {
 
             SectionType sectionType = pd.sectionContext();
             MarkdownNodeIterator cur = node;
-            Payload payload;
             std::stringstream ss;
 
             mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
 
             switch (sectionType) {
                 case ParametersSectionType:
-                    return ParametersParser::parse(node, siblings, pd, report, out.parameters);
+                {
+                    ParseResult<Parameters> parameters(out.report, out.node.parameters, out.sourceMap.parameters);
+                    return ParametersParser::parse(node, siblings, pd, parameters);
+                }
 
                 case RequestSectionType:
                 case RequestBodySectionType:
-                    cur = PayloadParser::parse(node, siblings, pd, report, payload);
+                {
+                    ParseResult<Payload> payload(out.report);
+                    cur = PayloadParser::parse(node, siblings, pd, payload);
 
-                    if (out.examples.empty() || !out.examples.back().responses.empty()) {
+                    if (out.node.examples.empty() || !out.node.examples.back().responses.empty()) {
                         TransactionExample transaction;
-                        out.examples.push_back(transaction);
+                        SourceMap<TransactionExample> transactionSM;
+
+                        out.node.examples.push_back(transaction);
+
+                        if (pd.exportSourceMap()) {
+                            out.sourceMap.examples.collection.push_back(transactionSM);
+                        }
                     }
 
-                    checkPayload(sectionType, sourceMap, payload, out, report);
+                    checkPayload(sectionType, sourceMap, payload.node, out);
+
+                    out.node.examples.back().requests.push_back(payload.node);
+
+                    if (pd.exportSourceMap()) {
+                        out.sourceMap.examples.collection.back().requests.collection.push_back(payload.sourceMap);
+                    }
 
-                    out.examples.back().requests.push_back(payload);
                     break;
+                }
 
                 case ResponseSectionType:
                 case ResponseBodySectionType:
-                    cur = PayloadParser::parse(node, siblings, pd, report, payload);
+                {
+                    ParseResult<Payload> payload(out.report);
+                    cur = PayloadParser::parse(node, siblings, pd, payload);
 
-                    if (out.examples.empty()) {
+                    if (out.node.examples.empty()) {
                         TransactionExample transaction;
-                        out.examples.push_back(transaction);
+                        SourceMap<TransactionExample> transactionSM;
+
+                        out.node.examples.push_back(transaction);
+
+                        if (pd.exportSourceMap()) {
+                            out.sourceMap.examples.collection.push_back(transactionSM);
+                        }
                     }
 
-                    checkPayload(sectionType, sourceMap, payload, out, report);
+                    checkPayload(sectionType, sourceMap, payload.node, out);
+
+                    out.node.examples.back().responses.push_back(payload.node);
+
+                    if (pd.exportSourceMap()) {
+                        out.sourceMap.examples.collection.back().responses.collection.push_back(payload.sourceMap);
+                    }
 
-                    out.examples.back().responses.push_back(payload);
                     break;
+                }
 
                 case HeadersSectionType:
-                    return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, report, out.headers);
+                {
+                    ParseResult<Headers> headers(out.report, out.node.headers, out.sourceMap.headers);
+                    return SectionProcessor<Action>::handleDeprecatedHeaders(node, siblings, pd, headers);
+                }
 
                 default:
                     break;
@@ -120,7 +163,7 @@ namespace snowcrash {
         static bool isUnexpectedNode(const MarkdownNodeIterator& node,
                                      SectionType sectionType) {
             
-            if ( SectionProcessor<Asset>::sectionType(node) != UndefinedSectionType) {
+            if (SectionProcessor<Asset>::sectionType(node) != UndefinedSectionType) {
                 return true;
             }
             
@@ -131,18 +174,21 @@ namespace snowcrash {
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& sectionType,
-                                                          Report& report,
-                                                          Action& out) {
+                                                          ParseResult<Action>& out) {
 
             if ((node->type == mdp::ParagraphMarkdownNodeType ||
                  node->type == mdp::CodeMarkdownNodeType) &&
                 (sectionType == ResponseBodySectionType ||
                  sectionType == ResponseSectionType) &&
-                !out.examples.empty() &&
-                !out.examples.back().responses.empty()) {
+                !out.node.examples.empty() &&
+                !out.node.examples.back().responses.empty()) {
+
+                mdp::ByteBuffer content = CodeBlockUtility::addDanglingAsset(node, pd, sectionType, out.report, out.node.examples.back().responses.back().body);
+
+                if (pd.exportSourceMap() && !content.empty()) {
+                    out.sourceMap.examples.collection.back().responses.collection.back().body.sourceMap.append(node->sourceMap);
+                }
 
-                CodeBlockUtility::addDanglingAsset(node, pd, sectionType, report, out.examples.back().responses.back().body);
-                
                 return ++MarkdownNodeIterator(node);
             }
             
@@ -150,11 +196,15 @@ namespace snowcrash {
                  node->type == mdp::CodeMarkdownNodeType) &&
                 (sectionType == RequestBodySectionType ||
                  sectionType == RequestSectionType) &&
-                !out.examples.empty() &&
-                !out.examples.back().requests.empty()) {
-                
-                CodeBlockUtility::addDanglingAsset(node, pd, sectionType, report, out.examples.back().requests.back().body);
+                !out.node.examples.empty() &&
+                !out.node.examples.back().requests.empty()) {
                 
+                mdp::ByteBuffer content = CodeBlockUtility::addDanglingAsset(node, pd, sectionType, out.report, out.node.examples.back().requests.back().body);
+
+                if (pd.exportSourceMap() && !content.empty()) {
+                    out.sourceMap.examples.collection.back().requests.collection.back().body.sourceMap.append(node->sourceMap);
+                }
+
                 return ++MarkdownNodeIterator(node);
             }
             
@@ -169,14 +219,14 @@ namespace snowcrash {
                 ss << "Ignoring " << SectionName(assetType) << " list item, ";
                 ss << SectionName(assetType) << " list item is expected to be indented by 4 spaces or 1 tab";
 
-                report.warnings.push_back(Warning(ss.str(),
-                                                  IgnoringWarning,
-                                                  sourceMap));
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      IgnoringWarning,
+                                                      sourceMap));
 
                 return ++MarkdownNodeIterator(node);
             }
             
-            return SectionProcessorBase<Action>::processUnexpectedNode(node, siblings, pd, sectionType, report, out);            
+            return SectionProcessorBase<Action>::processUnexpectedNode(node, siblings, pd, sectionType, out);            
         }
 
         static SectionType sectionType(const MarkdownNodeIterator& node) {
@@ -242,40 +292,43 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             Report& report,
-                             Action& out) {
+                             ParseResult<Action>& out) {
+
+            if (!out.node.headers.empty()) {
 
-            if (!out.headers.empty()) {
+                SectionProcessor<Headers>::injectDeprecatedHeaders(pd, out.node.headers, out.sourceMap.headers, out.node.examples, out.sourceMap.examples);
+                out.node.headers.clear();
 
-                SectionProcessor<Headers>::injectDeprecatedHeaders(out.headers, out.examples);
-                out.headers.clear();
+                if (pd.exportSourceMap()) {
+                    out.sourceMap.headers.collection.clear();
+                }
             }
 
-            if (out.examples.empty()) {
+            if (out.node.examples.empty()) {
 
                 // WARN: No response for action
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                report.warnings.push_back(Warning("action is missing a response",
-                                                  EmptyDefinitionWarning,
-                                                  sourceMap));
-            } else if (!out.examples.empty() &&
-                !out.examples.back().requests.empty() &&
-                out.examples.back().responses.empty()) {
+                out.report.warnings.push_back(Warning("action is missing a response",
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
+            } else if (!out.node.examples.empty() &&
+                !out.node.examples.back().requests.empty() &&
+                out.node.examples.back().responses.empty()) {
 
                 // WARN: No response for request
                 std::stringstream ss;
                 ss << "action is missing a response for ";
 
-                if (out.examples.back().requests.back().name.empty()) {
+                if (out.node.examples.back().requests.back().name.empty()) {
                     ss << "a request";
                 } else {
-                    ss << "the '" << out.examples.back().requests.back().name << "' request";
+                    ss << "the '" << out.node.examples.back().requests.back().name << "' request";
                 }
 
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                report.warnings.push_back(Warning(ss.str(),
-                                                  EmptyDefinitionWarning,
-                                                  sourceMap));
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
             }
         }
 
@@ -290,19 +343,18 @@ namespace snowcrash {
         static void checkPayload(SectionType sectionType,
                                  const mdp::CharactersRangeSet sourceMap,
                                  const Payload& payload,
-                                 const Action& action,
-                                 Report& report) {
+                                 ParseResult<Action>& out) {
 
-            if (isPayloadDuplicate(sectionType, payload, action.examples.back())) {
+            if (isPayloadDuplicate(sectionType, payload, out.node.examples.back())) {
 
                 // WARN: Duplicate payload
                 std::stringstream ss;
                 ss << SectionName(sectionType) << " payload `" << payload.name << "`";
-                ss << " already defined for `" << action.method << "` method";
+                ss << " already defined for `" << out.node.method << "` method";
 
-                report.warnings.push_back(Warning(ss.str(),
-                                                  DuplicateWarning,
-                                                  sourceMap));
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      DuplicateWarning,
+                                                      sourceMap));
             }
 
             if (sectionType == ResponseSectionType || sectionType == ResponseBodySectionType) {
@@ -313,27 +365,27 @@ namespace snowcrash {
                     std::stringstream(payload.name) >> code;
                 }
 
-                HTTPMethodTraits methodTraits = GetMethodTrait(action.method);
+                HTTPMethodTraits methodTraits = GetMethodTrait(out.node.method);
 
                 if (!methodTraits.allowBody && !payload.body.empty()) {
 
                     // WARN: Edge case for 2xx CONNECT
-                    if (action.method == HTTPMethodName::Connect && code/100 == 2) {
+                    if (out.node.method == HTTPMethodName::Connect && code/100 == 2) {
 
                         std::stringstream ss;
-                        ss << "the response for " << code << " " << action.method << " request MUST NOT include a " << SectionName(BodySectionType);
+                        ss << "the response for " << code << " " << out.node.method << " request MUST NOT include a " << SectionName(BodySectionType);
 
-                        report.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          sourceMap));
-                    } else if (action.method != HTTPMethodName::Connect && !methodTraits.allowBody) {
+                        out.report.warnings.push_back(Warning(ss.str(),
+                                                              EmptyDefinitionWarning,
+                                                              sourceMap));
+                    } else if (out.node.method != HTTPMethodName::Connect && !methodTraits.allowBody) {
 
                         std::stringstream ss;
-                        ss << "the response for " << action.method << " request MUST NOT include a " << SectionName(BodySectionType);
+                        ss << "the response for " << out.node.method << " request MUST NOT include a " << SectionName(BodySectionType);
 
-                        report.warnings.push_back(Warning(ss.str(),
-                                                          EmptyDefinitionWarning,
-                                                          sourceMap));
+                        out.report.warnings.push_back(Warning(ss.str(),
+                                                              EmptyDefinitionWarning,
+                                                              sourceMap));
                     }
 
                     return;
@@ -351,11 +403,11 @@ namespace snowcrash {
 
             if (sectionType == RequestSectionType) {
 
-                Collection<Request>::const_iterator duplicate = FindRequest(example, payload);
+                RequestIterator duplicate = SectionProcessor<Payload>::findRequest(example, payload);
                 return duplicate != example.requests.end();
             } else if (sectionType == ResponseSectionType) {
 
-                Collection<Response>::const_iterator duplicate = FindResponse(example, payload);
+                ResponseIterator duplicate = SectionProcessor<Payload>::findResponse(example, payload);
                 return duplicate != example.responses.end();
             }
 
@@ -366,19 +418,18 @@ namespace snowcrash {
         static MarkdownNodeIterator handleDeprecatedHeaders(const MarkdownNodeIterator& node,
                                                             const MarkdownNodes& siblings,
                                                             SectionParserData& pd,
-                                                            Report& report,
-                                                            Headers& headers) {
+                                                            ParseResult<Headers>& out) {
 
-            MarkdownNodeIterator cur = HeadersParser::parse(node, siblings, pd, report, headers);
+            MarkdownNodeIterator cur = HeadersParser::parse(node, siblings, pd, out);
 
             // WARN: Deprecated header sections
             std::stringstream ss;
             ss << "the 'headers' section at this level is deprecated and will be removed in a future, use respective payload header section(s) instead";
 
             mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-            report.warnings.push_back(Warning(ss.str(),
-                                              DeprecatedWarning,
-                                              sourceMap));
+            out.report.warnings.push_back(Warning(ss.str(),
+                                                  DeprecatedWarning,
+                                                  sourceMap));
 
             return cur;
         }
@@ -430,6 +481,15 @@ namespace snowcrash {
             
             return;
         }
+
+        /** Finds an action inside an actions collection */
+        static ActionIterator findAction(const Actions& actions,
+                                         const Action& action) {
+
+            return std::find_if(actions.begin(),
+                                actions.end(),
+                                std::bind2nd(MatchAction<Action>(), action));
+        }
     };
 
     /** Action Section Parser */