redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/BlueprintUtility.h

@@ -104,7 +104,7 @@ namespace snowcrash {
      *  \param  request A request to look for.
      *  \return Iterator pointing to the matching request within given method requests.
      */
-    FORCEINLINE Collection<Request>::const_iterator FindRequest(const TransactionExample& example, const Request& request) {
+    inline Collection<Request>::const_iterator FindRequest(const TransactionExample& example, const Request& request) {
         return std::find_if(example.requests.begin(),
                             example.requests.end(),
                             std::bind2nd(MatchPayload(), request));
@@ -116,7 +116,7 @@ namespace snowcrash {
      *  \param  response A response to look for.
      *  \return Iterator pointing to the matching response within given method requests.
      */
-    FORCEINLINE Collection<Response>::const_iterator FindResponse(const TransactionExample& example, const Response& response) {
+    inline Collection<Response>::const_iterator FindResponse(const TransactionExample& example, const Response& response) {
         return std::find_if(example.responses.begin(),
                             example.responses.end(),
                             std::bind2nd(MatchPayload(), response));

data/ext/snowcrash/src/CBlueprint.h

@@ -23,7 +23,7 @@ extern "C" {
     /** brief Blueprint Parser Options Enums */
     enum sc_blueprint_parser_option {
         SC_RENDER_DESCRIPTIONS_OPTION = (1 << 0),       /// < Render Markdown in description.
-        SC_REQUIRE_BLUEPRINT_NAME_OPTION = (1 << 1),    /// < Treat missing blueprint name as error
+        SC_REQUIRE_BLUEPRINT_NAME_OPTION = (1 << 1)     /// < Treat missing blueprint name as error
     };
 
     /** Parameter Use flag */

data/ext/snowcrash/src/CSourceAnnotation.cc

@@ -11,14 +11,14 @@
 #include "snowcrash.h"
 
 
-SC_API sc_result_t* sc_result_new()
+SC_API sc_report_t* sc_report_new()
 {
-    return AS_TYPE(sc_result_t, ::new snowcrash::Result);
+    return AS_TYPE(sc_report_t, ::new snowcrash::Report);
 }
 
-SC_API void sc_result_free(sc_result_t* result)
+SC_API void sc_report_free(sc_report_t* report)
 {
-    ::delete AS_TYPE(snowcrash::Result, result);
+    ::delete AS_TYPE(snowcrash::Report, report);
 }
 
 /*----------------------------------------------------------------------*/
@@ -33,7 +33,7 @@ SC_API const sc_location_t* sc_location_handler(const sc_source_annotation_t* so
 
 SC_API size_t sc_location_size(const sc_location_t* location)
 {
-    const snowcrash::SourceCharactersBlock* p = AS_CTYPE(snowcrash::SourceCharactersBlock, location);
+    const mdp::CharactersRangeSet* p = AS_CTYPE(mdp::CharactersRangeSet, location);
     if(!p)
         return 0;
     return p->size();
@@ -41,7 +41,7 @@ SC_API size_t sc_location_size(const sc_location_t* location)
 
 SC_API size_t sc_location_length(const sc_location_t* location, size_t index)
 {
-    const snowcrash::SourceCharactersBlock* p = AS_CTYPE(snowcrash::SourceCharactersBlock, location);
+    const mdp::CharactersRangeSet* p = AS_CTYPE(mdp::CharactersRangeSet, location);
     if(!p)
         return 0;
     return p->at(index).length;
@@ -49,7 +49,7 @@ SC_API size_t sc_location_length(const sc_location_t* location, size_t index)
 
 SC_API size_t sc_location_location(const sc_location_t* location, size_t index)
 {
-    const snowcrash::SourceCharactersBlock* p = AS_CTYPE(snowcrash::SourceCharactersBlock, location);
+    const mdp::CharactersRangeSet* p = AS_CTYPE(mdp::CharactersRangeSet, location);
     if(!p)
         return 0;
     return p->at(index).location;
@@ -57,9 +57,9 @@ SC_API size_t sc_location_location(const sc_location_t* location, size_t index)
 
 /*----------------------------------------------------------------------*/
 
-SC_API const sc_error_t* sc_error_handler(const sc_result_t* result)
+SC_API const sc_error_t* sc_error_handler(const sc_report_t* report)
 {
-    const snowcrash::Result* p = AS_CTYPE(snowcrash::Result, result);
+    const snowcrash::Report* p = AS_CTYPE(snowcrash::Report, report);
     if(!p)
         return NULL;
     return AS_CTYPE(sc_error_t, &p->error);
@@ -91,9 +91,9 @@ SC_API int sc_error_ok(const sc_error_t* error)
 
 /*----------------------------------------------------------------------*/
 
-SC_API const sc_warnings_t* sc_warnings_handler(const sc_result_t* result)
+SC_API const sc_warnings_t* sc_warnings_handler(const sc_report_t* report)
 {
-    const snowcrash::Result* p = AS_CTYPE(snowcrash::Result, result);
+    const snowcrash::Report* p = AS_CTYPE(snowcrash::Report, report);
     if(!p)
         return NULL;
     return AS_CTYPE(sc_warnings_t, &p->warnings);

data/ext/snowcrash/src/CSourceAnnotation.h

@@ -17,9 +17,9 @@
 extern "C" {
 #endif
 
-    /** Class Result wrapper */
-    struct sc_result_s;
-    typedef struct sc_result_s sc_result_t;
+    /** Class Report wrapper */
+    struct sc_report_s;
+    typedef struct sc_report_s sc_report_t;
 
     /** Array warnings wrapper */
     struct sc_warnings_s;
@@ -43,11 +43,11 @@ extern "C" {
 
     /*----------------------------------------------------------------------*/
 
-    /** \returns pointer to allocated Result*/
-    SC_API sc_result_t* sc_result_new();
+    /** \returns pointer to allocated Report*/
+    SC_API sc_report_t* sc_report_new();
 
-    /** \deallocate Result from pointer*/
-    SC_API void sc_result_free(sc_result_t* result);
+    /** \deallocate Report from pointer*/
+    SC_API void sc_report_free(sc_report_t* report);
 
     /*----------------------------------------------------------------------*/
 
@@ -66,7 +66,7 @@ extern "C" {
     /*----------------------------------------------------------------------*/
 
     /** \returns error handler*/
-    SC_API const sc_error_t* sc_error_handler(const sc_result_t* result);
+    SC_API const sc_error_t* sc_error_handler(const sc_report_t* report);
 
     /** \returns error message*/
     SC_API const char* sc_error_message(const sc_error_t* error);
@@ -80,7 +80,7 @@ extern "C" {
     /*----------------------------------------------------------------------*/
 
     /** \returns warnings handler*/
-    SC_API const sc_warnings_t* sc_warnings_handler(const sc_result_t* result);
+    SC_API const sc_warnings_t* sc_warnings_handler(const sc_report_t* report);
 
     /** \returns warnings array size*/
     SC_API size_t sc_warnings_size(const sc_warnings_t* warning);

data/ext/snowcrash/src/CodeBlockUtility.h

@@ -10,180 +10,230 @@
 #define SNOWCRASH_CODEBLOCKUTILITY_H
 
 #include <sstream>
-#include "BlockUtility.h"
+#include "Section.h"
+#include "StringUtility.h"
 
 namespace snowcrash {
     
-    /**
-     *  Compute expected indentation level of a code block.
-     *  \param  section A section to compute indentation level for
-     *  \return Indentation level (number of tabs) for a block to be
-     *  considered a pre-formatted code block in given section.
-     */
-    FORCEINLINE size_t CodeBlockIndentationLevel(const BlueprintSection& section)
-    {
-        if (!section.hasParent() ||
-            section.parent().type == BlueprintSectionType ||
-            section.parent().type == ResourceGroupSectionType ||
-            section.parent().type == ResourceSectionType ||
-            section.parent().type == ResourceMethodSectionType ||
-            section.parent().type == ActionSectionType) {
-            
-            return 1;
+    struct CodeBlockUtility {
+        
+        /**
+         *  \brief Expected indentation level of a code block.
+         *
+         *  \param  type    Section type to retrieve the indentation level for
+         *  \return Indentation level (number of tabs) for a block to be
+         *          considered a pre-formatted code block in given section.
+         */
+        static size_t codeBlockIndentationLevel(const SectionType& type)
+        {
+            if (type == BlueprintSectionType ||
+                type == ResourceGroupSectionType ||
+                type == ResourceSectionType ||
+                type == ActionSectionType) {
+                
+                return 1;
+            }
+            else if (type == RequestBodySectionType ||
+                     type == ResponseBodySectionType ||
+                     type == ModelBodySectionType) {
+                
+                return 2;
+            }
+            else {
+                
+                return 3;
+            }
         }
-        else if (section.parent().type == RequestBodySectionType ||
-                 section.parent().type == ResponseBodySectionType ||
-                 section.parent().type == ObjectBodySectionType ||
-                 section.parent().type == ModelBodySectionType) {
+        
+        /**
+         *  \brief  Retrieve the textual content of a Markdown node as if it was a code block.
+         *  \param  pd      Parser status
+         *  \param  report  Report log
+         *  \param  conten  The content retrieved
+         */
+        static void contentAsCodeBlock(const MarkdownNodeIterator& node,
+                                       const SectionParserData& pd,
+                                       Report& report,
+                                       mdp::ByteBuffer& content) {
             
-            return 2;
-        }
-        else {
+            if (node->type == mdp::CodeMarkdownNodeType) {
+                content += node->text;
+
+                checkExcessiveIndentation(node, pd, report);
+                return;
+            }
+            
+            // Other blocks, process & warn
+            content += mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+
+            // WARN: Not a preformatted code block
+            size_t level = codeBlockIndentationLevel(pd.parentSectionContext());
+            std::stringstream ss;
+            ss << SectionName(pd.sectionContext());
+
+            if (pd.sectionContext() == BodySectionType) {
+                ss << " asset";
+            }
+
+            ss << " is expected to be a pre-formatted code block, every of its line indented by exactly ";
+            ss << level * 4 << " spaces or " << level << " tabs";
             
-            return 3;
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.warnings.push_back(Warning(ss.str(),
+                                              IndentationWarning,
+                                              sourceMap));
         }
-    }
-    
-    /**
-     *  \brief Check code block for potential excessive indentation of a list item.
-     *  \return True if code block does not contain potential recognized list, false otherwise.
-     */
-    template <class T>
-    FORCEINLINE bool CheckCodeBlockListItem(const BlueprintSection& section,
-                                            const BlockIterator& cur,
-                                            const SourceData& sourceData,
-                                            Result& result)
-    {
-        
-        // Check for possible superfluous indentation of a recognized list items.
-        std::string line = GetFirstLine(cur->content);
-        TrimStringStart(line);
         
-        // If line appears to be a Markdown list construct a dummy list item
-        // with the first line of code block as its content.
-        // Check the list item with respective internal classifier.
-        if (line.empty() ||
-            (line[0] != '-' && line[0] != '+' && line[0] != '*'))
-            return true;
-        
-        // Skip leading Markdown list item mark
-        std::string listItemContent = line.substr(1, std::string::npos);
-        TrimStringStart(listItemContent);
-        MarkdownBlock::Stack dummyList;
-        
-        dummyList.push_back(MarkdownBlock(ListItemBlockBeginType, SourceData(), 0, SourceDataBlock()));
-        dummyList.push_back(MarkdownBlock(ListItemBlockEndType, listItemContent, 0, MakeSourceDataBlock(0, 0)));
-        
-        SectionType type = ClassifyInternaListBlock<T>(dummyList.begin(), dummyList.end());
-        if (type != UndefinedSectionType) {
+        /** \brief  Retrieve the textual content of a signature markdown */
+        static void signatureContentAsCodeBlock(const MarkdownNodeIterator& node,
+                                                const SectionParserData& pd,
+                                                Report& report,
+                                                mdp::ByteBuffer& content) {
             
-            size_t level = CodeBlockIndentationLevel(section);
-            --level;
+            mdp::ByteBuffer remainingContent;
+            GetFirstLine(node->text, remainingContent);
             
-            // WARN: Superfluous indentation
+            if (remainingContent.empty())
+                return;
+            
+            content += remainingContent;
+            content += "\n";
+
+            // WARN: Not a preformatted code block but multiline signature
+            size_t level = codeBlockIndentationLevel(pd.parentSectionContext());
             std::stringstream ss;
-            ss << "excessive indentation, ";
-            ss << SectionName(type) << " ";
-            if (level) {
-                ss << "section is expected to be indented by just ";
-                ss << level * 4 << " spaces or " << level << " tab";
-                if (level > 1)
-                    ss << "s";
-            }
-            else {
-                ss << "section is not expected to be indented";
+
+            ss << SectionName(pd.sectionContext());
+
+            if (pd.sectionContext() == BodySectionType) {
+                ss << " asset";
             }
+
+            ss << " is expected to be a pre-formatted code block, separate it by a newline and ";
+            ss << "indent every of its line by ";
+            ss << level * 4 << " spaces or " << level << " tabs";
             
-            SourceCharactersBlock sourceBlock = CharacterMapForBlock(cur,
-                                                                     cur,
-                                                                     section.bounds,
-                                                                     sourceData);
-            result.warnings.push_back(Warning(ss.str(),
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.warnings.push_back(Warning(ss.str(),
                                               IndentationWarning,
-                                              sourceBlock));
-            
-            return false;
+                                              sourceMap));
         }
         
-        return true;
-    }
-    
-    /**
-     *  \brief  Parses given block as a preformatted code block.
-     *  \param  section     Actual section being parsed.
-     *  \param  cur         Cursor within the section boundaries.
-     *  \param  parser      Parser instance.
-     *  \param  action      An output data buffer.
-     *  \param  sourceMap   An output source map buffer.
-     *  \return A block parser section result, pointing at the last block parsed.
-     */
-    template <class T>
-    FORCEINLINE ParseSectionResult ParsePreformattedBlock(const BlueprintSection& section,
-                                                          const BlockIterator& cur,
-                                                          BlueprintParserCore& parser,
-                                                          SourceData& data,
-                                                          SourceDataBlock& sourceMap) {
-        
-        ParseSectionResult result = std::make_pair(Result(), cur);
-        BlockIterator sectionCur = cur;
-        std::stringstream dataStream;
-        
-        if (sectionCur->type == CodeBlockType) {
-            // Well formatted content, stream it up
-            dataStream << sectionCur->content;
+        /**
+         *  \brief Check for potential excessive indentation of a list section
+         *  \return True if code block contains a recognized list section, false otherwise.
+         */
+        static bool checkExcessiveIndentation(const MarkdownNodeIterator& node,
+                                              const SectionParserData& pd,
+                                              Report& report) {
             
-            // Check for excessive indentation
-            CheckCodeBlockListItem<T>(section, sectionCur, parser.sourceData, result.first);
-        }
-        else {
-            // Other blocks, process & warn
-            if (sectionCur->type == QuoteBlockBeginType) {
-                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, QuoteBlockBeginType, QuoteBlockEndType);
-            }
-            else if (sectionCur->type == ListBlockBeginType) {
-                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListBlockBeginType, ListBlockEndType);
-            }
-            else if (sectionCur->type == ListItemBlockBeginType) {
-                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListItemBlockBeginType, ListItemBlockEndType);
+            // Check for possible superfluous indentation of a recognized list items.
+            mdp::ByteBuffer r;
+            mdp::ByteBuffer line = GetFirstLine(node->text, r);
+            TrimString(line);
+
+            // If line appears to be a Markdown list.
+            if (line.empty() ||
+                (line[0] != '-' && line[0] != '+' && line[0] != '*'))
+                return false;
+            
+            // Skip leading Markdown list item mark
+            std::string signature = line.substr(1, std::string::npos);
+            TrimStringStart(signature);
+            
+            SectionType type = RecognizeCodeBlockFirstLine(signature);
+
+            if (type != UndefinedSectionType) {
+
+                // Check signature.
+                size_t level = codeBlockIndentationLevel(pd.sectionContext());
+                --level;
+
+                // WARN: Superfluous indentation
+                std::stringstream ss;
+                ss << "excessive indentation, ";
+                ss << SectionName(type) << " ";
+
+                if (level) {
+                    ss << "section is expected to be indented by just ";
+                    ss << level * 4 << " spaces or " << level << " tab";
+
+                    if (level > 1)
+                        ss << "s";
+                }
+                else {
+                    ss << "section is not expected to be indented";
+                }
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IndentationWarning,
+                                                  sourceMap));
             }
             
-            if (!CheckCursor(section, sectionCur, parser.sourceData, result.first))
-                return result;
-            dataStream << MapSourceData(parser.sourceData, sectionCur->sourceMap);
+            return false;
+        }
+
+        /**
+         *  \brief  Parse one line of raw `key:value` data.
+         *  \param  line            A line to parse
+         *  \param  keyValuePair    The output buffer to place the parsed data into
+         *  \return True on success, false otherwise
+         */
+        static bool keyValueFromLine(const mdp::ByteBuffer& line,
+                                    KeyValuePair& keyValuePair) {
             
-            // WARN: Not a preformatted code block
-            std::stringstream ss;
+            std::vector<std::string> rawMetadata = SplitOnFirst(line, ':');
+            if (rawMetadata.size() != 2)
+                return false;
             
-            // Build the warning message
-            size_t level = CodeBlockIndentationLevel(section);
-            if (section.type == DanglingBodySectionType ||
-                section.type == DanglingSchemaSectionType) {
-                
-                ss << "dangling " << SectionName(section.type) << " asset, ";
-                ss << "expected a pre-formatted code block, indent every of its line by ";
-                ss << level * 4 << " spaces or " << level << " tabs";
+            keyValuePair = std::make_pair(rawMetadata[0], rawMetadata[1]);
+            TrimString(keyValuePair.first);
+            TrimString(keyValuePair.second);
+            
+            return (!keyValuePair.first.empty() && !keyValuePair.second.empty());
+        }
+
+        /**
+         *  \brief Add dangling message body asset to the given string
+         *  \param  out  The string to which the dangling asset should be added
+         */
+        static void addDanglingAsset(const MarkdownNodeIterator& node,
+                                     SectionParserData& pd,
+                                     SectionType& sectionType,
+                                     Report& report,
+                                     mdp::ByteBuffer& out) {
+
+            mdp::ByteBuffer asset;
+
+            if (node->type == mdp::CodeMarkdownNodeType) {
+                asset = node->text;
+            } else {
+                asset = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
             }
-            else {
+
+            TwoNewLines(asset);
+            out += asset;
+            
+            size_t level = CodeBlockUtility::codeBlockIndentationLevel(sectionType);
+
+            if (node->type == mdp::CodeMarkdownNodeType)
+                level--;  // Deduct one level for a code block
+
                 
-                ss << SectionName(section.type) << " asset ";
-                ss << "is expected to be a pre-formatted code block, every of its line indented by exactly ";
-                ss << level * 4 << " spaces or " << level << " tabs";
+            if (level) {
+                // WARN: Dangling asset
+                std::stringstream ss;
+                ss << "dangling message-body asset, expected a pre-formatted code block, ";
+                ss << "indent every of it's line by " << level*4 << " spaces or " << level << " tabs";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IndentationWarning,
+                                                  sourceMap));
             }
-            
-            SourceCharactersBlock sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, parser.sourceData);
-            result.first.warnings.push_back(Warning(ss.str(),
-                                                    IndentationWarning,
-                                                    sourceBlock));
         }
-        
-        data = dataStream.str();
-        sourceMap = sectionCur->sourceMap;
-        
-        if (sectionCur != section.bounds.second)
-            result.second = ++sectionCur;
-        
-        return result;
-    }
+    };
 }
 
 #endif