redsnow 0.0.8

data/ext/snowcrash/src/HTTP.cc

@@ -0,0 +1,46 @@
+//
+//  HTTP.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/11/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "HTTP.h"
+
+using namespace snowcrash;
+
+const std::string HTTPHeaderName::Accept = "Accept";
+const std::string HTTPHeaderName::ContentLength = "Content-Length";
+const std::string HTTPHeaderName::ContentType = "Content-Type";
+const std::string HTTPHeaderName::TransferEncoding = "Transfer-Encoding";
+
+const std::string HTTPMethodName::Head = "HEAD";
+const std::string HTTPMethodName::Connect = "CONNECT";
+
+StatusCodeTraits snowcrash::GetStatusCodeTrait(HTTPStatusCode code)
+{
+    StatusCodeTraits traits;
+    traits.code = code;
+
+    // Following status codes MUST NOT contain response body
+    if (code == 204 || code == 304 || code/100 == 1) {
+        traits.allowBody = false;
+    }
+
+    return traits;
+}
+
+HTTPMethodTraits snowcrash::GetMethodTrait(HTTPMethod method)
+{
+    HTTPMethodTraits traits;
+    traits.method = method;
+
+    // Following HTTP methods MUST NOT contain response body
+    // FIXME: When refactoring traits don't forget that 'CONNECT' has no body only when 1xx-2xx
+    if (method == HTTPMethodName::Head || method == HTTPMethodName::Connect) {
+        traits.allowBody = false;
+    }
+
+    return traits;
+}

data/ext/snowcrash/src/HTTP.h

@@ -0,0 +1,105 @@
+//
+//  HTTP.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/11/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_HTTP_H
+#define SNOWCRASH_HTTP_H
+
+#include <string>
+#include "Blueprint.h"
+
+/**
+ *  \brief HTTP Methods 
+ *
+ *  Technical note: Using preprocessor macro instead of strict
+ *  defined type due to C++98 string concatenation limitations.
+ *  FIXME: To be improved with migration to C++11.
+ */
+#define HTTP_REQUEST_METHOD "(GET|POST|PUT|DELETE|OPTIONS|PATCH|PROPPATCH|LOCK|UNLOCK|COPY|MOVE|MKCOL|HEAD|LINK|UNLINK|CONNECT)"
+
+/** 
+ *  \brief URI Template.
+ *
+ *  See previous technical note (using macro).
+ */
+#define URI_TEMPLATE "(/.*)"
+
+namespace snowcrash {
+    
+    /**
+     *  Selected HTTP Header names.
+     */
+    struct HTTPHeaderName {
+        static const std::string Accept;
+        static const std::string ContentLength;
+        static const std::string ContentType;
+        static const std::string TransferEncoding;
+    };
+
+    /**
+     * Selected HTTP Method names.
+     */
+    struct HTTPMethodName {
+        static const std::string Head;
+        static const std::string Connect;
+    };
+
+    /**
+     *  A HTTP Status code.
+     */
+    typedef unsigned int HTTPStatusCode;
+
+    /**
+     *  Traits of a HTTP response.
+     */
+    struct HTTPResponseTraits {
+        
+        bool allowBody; /// < Response body is allowed.
+        
+        HTTPResponseTraits() : allowBody(true) {}
+    };
+
+    /**
+     *  Response traits for a HTTP method.
+     *
+     *  HTTP request method related response prescription
+     *  Ref: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html
+     */
+    struct HTTPMethodTraits : HTTPResponseTraits
+    {
+        HTTPMethod method;
+        HTTPMethodTraits() : method("") {}
+    };
+
+    /**
+     *  Response traits for a HTTP status code.
+     *
+     *  Status-related response prescription.
+     *  Ref: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+     */
+    struct StatusCodeTraits : HTTPResponseTraits
+    {
+        HTTPStatusCode code;
+        StatusCodeTraits() : code(0) {}
+    };
+    
+    /**
+     *  \brief  Retrieve response traits for given HTTP method.
+     *  \param  method  HTTP method to retrieve traits for.
+     *  \return A %HTTPMethodTraits for given method.
+     */
+    extern HTTPMethodTraits GetMethodTrait(HTTPMethod method);
+
+    /**
+     *  \brief  Retrieve response traits for given status code.
+     *  \param  code    A HTTP status code to retrieve traits for.
+     *  \return A %StatusCodeTraits for given code.
+     */
+    extern StatusCodeTraits GetStatusCodeTrait(HTTPStatusCode code);
+}
+
+#endif

data/ext/snowcrash/src/HeaderParser.h

@@ -0,0 +1,289 @@
+//
+//  HeaderParser.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/22/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_HEADERPARSER_H
+#define SNOWCRASH_HEADERPARSER_H
+
+#include <sstream>
+#include "BlueprintParserCore.h"
+#include "Blueprint.h"
+#include "RegexMatch.h"
+#include "StringUtility.h"
+#include "ListBlockUtility.h"
+
+namespace snowcrashconst {
+    
+    /** Headers matching regex */
+    const char* const HeadersRegex = "^[[:blank:]]*[Hh]eaders?[[:blank:]]*$";
+}
+
+namespace snowcrash {
+
+    // Internal type alias for Collection of Headers
+    typedef Collection<Header>::type HeaderCollection;
+    
+    // Query header signature a of given block
+    FORCEINLINE bool HasHeaderSignature(const BlockIterator& begin,
+                                        const BlockIterator& end) {
+        
+        if (begin->type == ListBlockBeginType || begin->type == ListItemBlockBeginType) {
+            
+            BlockIterator cur = ListItemNameBlock(begin, end);
+            if (cur == end)
+                return false;
+            
+            if (cur->type != ParagraphBlockType &&
+                cur->type != ListItemBlockEndType)
+                return false;
+            
+            std::string content = GetFirstLine(cur->content);
+            return RegexMatch(content, snowcrashconst::HeadersRegex);
+        }
+        
+        return false;
+    }
+    
+    // Header iterator in its containment group
+    typedef Collection<Header>::const_iterator HeaderIterator;
+    
+    // Finds a header in its containment group by its key (first)
+    FORCEINLINE HeaderIterator FindHeader(const HeaderCollection& headers,
+                                          const Header& header) {
+        
+        return std::find_if(headers.begin(),
+                            headers.end(),
+                            std::bind2nd(MatchFirsts<Header>(), header));
+    }
+    
+    /** Internal list items classifier, Headers Context */
+    template <>
+    FORCEINLINE SectionType ClassifyInternaListBlock<HeaderCollection>(const BlockIterator& begin,
+                                                                       const BlockIterator& end) {
+        return UndefinedSectionType;
+    }
+    
+    /** Children List Block Classifier, HeaderCollection context. */
+    template <>
+    FORCEINLINE SectionType ClassifyChildrenListBlock<HeaderCollection>(const BlockIterator& begin,
+                                                                        const BlockIterator& end){
+        return UndefinedSectionType;
+    }
+    
+    /** Block Classifier, Headers Context */
+    template <>
+    FORCEINLINE SectionType ClassifyBlock<HeaderCollection>(const BlockIterator& begin,
+                                                        const BlockIterator& end,
+                                                        const SectionType& context) {
+        
+        if (context == UndefinedSectionType &&
+            HasHeaderSignature(begin, end)) {
+            return HeadersSectionType;
+        }
+        else if (context == HeadersSectionType) {
+            
+            // SectionType closure
+            if (begin->type == ListItemBlockEndType ||
+                begin->type == ListBlockEndType)
+                return UndefinedSectionType;
+            
+            // Adjacent list item
+            if (begin->type == ListItemBlockBeginType)
+                return UndefinedSectionType;
+        }
+        
+        return (context == HeadersSectionType) ? context : UndefinedSectionType;
+    }
+    
+    //
+    // Headers SectionType Parser
+    //
+    template<>
+    struct SectionParser<HeaderCollection> {
+        
+        static ParseSectionResult ParseSection(const BlueprintSection& section,
+                                               const BlockIterator& cur,
+                                               BlueprintParserCore& parser,
+                                               HeaderCollection& headers) {
+            
+            ParseSectionResult result = std::make_pair(Result(), cur);
+            switch (section.type) {
+                case HeadersSectionType:
+                    result = HandleHeadersSectionBlock(section, cur, parser, headers);
+                    break;
+                    
+                case UndefinedSectionType:
+                    result.second = CloseList(cur, section.bounds.second);
+                    break;
+                    
+                default:
+                    result.first.error = UnexpectedBlockError(section, cur, parser.sourceData);
+                    break;
+            }
+            
+            return result;
+        }
+        
+        static void Finalize(const SectionBounds& bounds,
+                             BlueprintParserCore& parser,
+                             HeaderCollection& headers,
+                             Result& result) {}
+
+        static ParseSectionResult HandleHeadersSectionBlock(const BlueprintSection& section,
+                                                            const BlockIterator& cur,
+                                                            BlueprintParserCore& parser,
+                                                            HeaderCollection& headers) {
+
+            SourceData data;
+            SourceDataBlock sourceMap;
+            ParseSectionResult result = ParseListPreformattedBlock<HeaderCollection>(section,
+                                                                                     cur,
+                                                                                     parser,
+                                                                                     data,
+                                                                                     sourceMap);
+            if (result.first.error.code != Error::OK ||
+                parser.sourceData.empty())
+                return result;
+            
+            // Proces raw data
+            std::vector<std::string> lines = Split(data, '\n');
+            for (std::vector<std::string>::iterator line = lines.begin();
+                 line != lines.end();
+                 ++line) {
+                
+                Header header;
+                if (KeyValueFromLine(*line, header)) {
+                    
+                    if (FindHeader(headers, header) != headers.end()) {
+                        // WARN: duplicate header on this level
+                        std::stringstream ss;
+                        ss << "duplicate definition of '" << header.first << "' header";
+                        
+                        result.first.warnings.push_back(Warning(ss.str(),
+                                                                DuplicateWarning,
+                                                                MapSourceDataBlock(sourceMap, parser.sourceData)));
+                        
+                    }
+                        
+                    headers.push_back(header);
+                }
+                else {
+                    // WARN: unable to parse header
+                    result.first.warnings.push_back(Warning("unable to parse HTTP header, expected"
+                                                            " '<header name> : <header value>', one header per line",
+                                               FormattingWarning,
+                                               MapSourceDataBlock(sourceMap, parser.sourceData)));
+                }
+            }
+            
+            return result;
+        }
+    };
+
+    typedef BlockParser<HeaderCollection, SectionParser<HeaderCollection> > HeadersParser;
+    
+    /**
+     *  Generic HeaderSection parser handler
+     */
+    template <class T>
+    ParseSectionResult HandleHeaders(const BlueprintSection& section,
+                                     const BlockIterator& cur,
+                                     BlueprintParserCore& parser,
+                                     T& t)
+    {
+        size_t headerCount = t.headers.size();
+        ParseSectionResult result = HeadersParser::Parse(cur,
+                                                         section.bounds.second,
+                                                         section,
+                                                         parser,
+                                                         t.headers);
+        if (result.first.error.code != Error::OK)
+            return result;
+        
+        if (t.headers.size() == headerCount) {
+            BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
+            result.first.warnings.push_back(Warning("no headers specified",
+                                                    FormattingWarning,
+                                                    sourceBlock));
+        }
+        return result;
+    }
+    
+    
+    /** Helper for handling parsing of deprecated header sections */
+    template <typename T>
+    ParseSectionResult HandleDeprecatedHeaders(const BlueprintSection& section,
+                                               const BlockIterator& cur,
+                                               BlueprintParserCore& parser,
+                                               T& t) {
+        
+        ParseSectionResult result = HandleHeaders<T>(section, cur, parser, t);
+        
+        // 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";
+        BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
+        SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
+        result.first.warnings.push_back(Warning(ss.str(),
+                                                DeprecatedWarning,
+                                                sourceBlock));
+        return result;
+    }
+    
+    /** \brief Copy headers into example paylods headers. */
+    FORCEINLINE void InjectDeprecatedHeaders(const Collection<Header>::type& headers,
+                                        Collection<TransactionExample>::type& examples)
+    {
+        for (Collection<TransactionExample>::iterator exampleIt = examples.begin();
+             exampleIt != examples.end();
+             ++exampleIt) {
+            
+            // Requests
+            for (Collection<Request>::iterator reqIt = exampleIt->requests.begin();
+                 reqIt != exampleIt->requests.end();
+                 ++reqIt) {
+                
+                reqIt->headers.insert(reqIt->headers.begin(),
+                                      headers.begin(),
+                                      headers.end());
+            }
+            
+            // Responses
+            for (Collection<Response>::iterator resIt = exampleIt->responses.begin();
+                 resIt != exampleIt->responses.end();
+                 ++resIt) {
+                
+                resIt->headers.insert(resIt->headers.begin(),
+                                      headers.begin(),
+                                      headers.end());
+            }
+        }
+    }
+    
+    // Checks T's headers for occurence of R's headers, warns if a match is found.
+    template <class T, class R>
+    void CheckHeaderDuplicates(const T& left,
+                               const R& right,
+                               const SourceDataBlock& rightSourceMap,
+                               const SourceData& sourceData,
+                               Result& result) {
+        
+        for (HeaderIterator it = right.headers.begin(); it != right.headers.end(); ++it) {
+            if (FindHeader(left.headers, *it) != left.headers.end()) {
+                // WARN: overshadowing header definition
+                std::stringstream ss;
+                ss << "overshadowing previous '" << it->first << "' header definition";
+                result.warnings.push_back(Warning(ss.str(),
+                                                  RedefinitionWarning,
+                                                  MapSourceDataBlock(rightSourceMap, sourceData)));
+            }
+        }
+    }
+}
+
+#endif

data/ext/snowcrash/src/ListBlockUtility.h

@@ -0,0 +1,273 @@
+//
+//  ListBlockUtility.h
+//  snowcrash
+//
+//  All the cool kids from ListUtility.h live here.
+//
+//  Created by Zdenek Nemec on 11/11/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_LISTBLOCKUTILITY_H
+#define SNOWCRASH_LISTBLOCKUTILITY_H
+
+#include "ListUtility.h"
+
+namespace snowcrash {
+    
+    /**
+     *  \brief  Return a first non-signature content block of a list(item).
+     *  \param  begin    Begin of the block buffer to examine.
+     *  \param  end      End of the block buffer.
+     *  \return First non-signature content block or begin.
+     *
+     *  Returns first block with the actual content of a list or list item.
+     */
+    FORCEINLINE BlockIterator ContentBlock(const BlockIterator& begin,
+                                           const BlockIterator& end) {
+        
+        BlockIterator cur = begin;
+        if (cur->type == ListBlockBeginType) {
+            if (++cur == end)
+                return end;
+            
+            return cur;
+        }
+        
+        if (cur->type == ListItemBlockBeginType) {
+            if (++cur == end)
+                return end;
+            
+            if (cur->type == ListItemBlockEndType)
+                return begin;
+            
+            if (cur->type == ParagraphBlockType)
+                if (++cur == end)
+                    return end;
+        }
+        
+        return cur;
+    }
+
+    /**
+     * \brief   Skips first list item signature block.
+     *
+     *  This function effectively returns the first content block of
+     *  a list item that is not a signature block. If no such a block exists.
+     *  a block following the list item is returned. If a list is provided it
+     *  uses its first list item.
+     */
+    FORCEINLINE BlockIterator SkipSignatureBlock(const BlockIterator& begin,
+                                                 const BlockIterator& end) {
+        
+        BlockIterator cur = begin;
+        
+        // Skip to fist list item if appropriate
+        if (cur->type == ListBlockBeginType) {
+            cur = ContentBlock(cur, end);
+        }
+        
+        // Skip to first list item content
+        if (cur->type == ListItemBlockBeginType) {
+            BlockIterator firstContent = ContentBlock(cur, end);
+            if (cur != firstContent) {
+                cur = firstContent;
+            }
+            else {
+                // No content, just move to the next block
+                ++cur;
+            }
+        }
+        
+        return cur;
+    }
+    
+    // Return name block of list item; that is either FirstContentBlock() or
+    // matching closing item block for inline items
+    FORCEINLINE BlockIterator ListItemNameBlock(const BlockIterator& begin,
+                                                const BlockIterator& end) {
+        
+        BlockIterator cur = FirstContentBlock(begin, end);
+        if (cur == end ||
+            cur->type != ListBlockBeginType)
+            return cur;
+        
+        // Inline list block
+        cur = SkipToClosingBlock(cur, end, ListBlockBeginType, ListBlockEndType);
+        if (cur != end)
+            return ++cur;
+        
+        return cur;
+    }
+    
+    /**
+     *  \brief  Eats closing blocks of a list / list item block.
+     *  \param  begin   Cursor to a list or list item closing block.
+     *  \param  end     End of a block buffer.
+     *  \return Block AFTER closed list / list item.
+     *
+     *  Skips over subsequent ListItemBlockEndType and ListBlockEndType returning the fist
+     *  other block after.
+     */
+    FORCEINLINE BlockIterator CloseList(const BlockIterator& begin,
+                                        const BlockIterator& end) {
+        
+        BlockIterator cur = begin;
+        if (cur != end &&
+            cur->type == ListItemBlockEndType) {
+            ++cur; // eat list item end
+        }
+        
+        if (cur != end &&
+            cur->type == ListBlockEndType) {
+            ++cur; // eat list end
+        }
+        
+        return cur;
+    }
+    
+    /**
+     *  \brief  Skips COMPLETE consecutive (nested) closing elements of a list or a list item.
+     *  \param  begin   The begin of a list or a list item.
+     *  \param  end     End of markdown block buffer.
+     *  \return An iterator pointing AFTER the last closing list / list item block.
+     */
+    FORCEINLINE BlockIterator CloseNestedList(const BlockIterator& begin,
+                                              const BlockIterator& end) {
+        BlockIterator cur = begin;
+        while (cur != end &&
+               (cur->type == ListItemBlockEndType || cur->type == ListBlockEndType)) {
+            cur = CloseList(cur, end);
+        }
+        return cur;
+    }
+    
+    /**
+     *  \brief  Extract the first line of a list item content - its signature
+     *  \param  cur  The begining of the list item to get its signature.
+     *  \param  end  The begining of a block buffer.
+     *  \param  remainingContent Any additonal content after the first line of signature.
+     *  \return First line of the list item signature.
+     */
+    FORCEINLINE SourceData GetListItemSignature(const BlockIterator& cur,
+                                                const BlockIterator& end,
+                                                SourceData& remainingContent) {
+        
+        BlockIterator sectionCur = ListItemNameBlock(cur, end);
+        if (sectionCur == end)
+            return SourceData();
+        
+        ContentParts content = ExtractFirstLine(*sectionCur);
+        if (content.empty() ||
+            content.front().empty())
+            return SourceData();
+        
+        if (content.size() == 2)
+            remainingContent = content[1];
+        
+        return content[0];
+    }
+    
+    /**
+     *  \brief Check List Item signature for an addtional content and issue a warning.
+     *  \param section  Current section to be checked.
+     *  \param cur      The begining of the list item to check.
+     *  \param bounds   Bounds within the block buffer.
+     *  \param sourceData   Source data byte buffer.
+     *  \param placeHint    A string explaining the possible place of failure. Might be empty.
+     *  \param expectedHint A string defining expected content. Might be empty.
+     *  \param result   Result to append the possible warning into.
+     *  \return True if signagure contains no additional content, false otherwise.
+     */
+    FORCEINLINE bool CheckSignatureAdditionalContent(const BlueprintSection& section,
+                                                     const BlockIterator& cur,
+                                                     const SourceData& sourceData,
+                                                     const std::string& placeHint,
+                                                     const std::string& expectedHint,
+                                                     Result& result)
+    {
+        SourceData remainingContent;
+        SourceData signature = GetListItemSignature(cur, section.bounds.second, remainingContent);
+        
+        if (!remainingContent.empty()) {
+            // WARN: Superfluous content in signature
+            
+            std::stringstream ss;
+            ss << "ignoring additional content";
+            
+            if (!placeHint.empty())
+                ss << " after " << placeHint;
+            
+            if (!expectedHint.empty())
+                ss << ", expected " << expectedHint;
+            
+            BlockIterator nameBlock = ListItemNameBlock(cur, section.bounds.second);
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, sourceData);
+            result.warnings.push_back(Warning(ss.str(),
+                                              IgnoringWarning,
+                                              sourceBlock));
+        }
+        
+        return remainingContent.empty();
+    }
+    
+    /**
+     *  \brief  Parses list (item) 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 AFTER the last block parsed.
+     */
+    template <class T>
+    FORCEINLINE ParseSectionResult ParseListPreformattedBlock(const BlueprintSection& section,
+                                                              const BlockIterator& cur,
+                                                              BlueprintParserCore& parser,
+                                                              SourceData& data,
+                                                              SourceDataBlock& sourceMap) {
+        
+        ParseSectionResult result = std::make_pair(Result(), cur);
+        BlockIterator sectionCur = cur;
+        
+        if (sectionCur != section.bounds.first) {
+            // Parse subsequent blocks as standalone pre blocks.
+            return ParsePreformattedBlock<T>(section, sectionCur, parser, data, sourceMap);
+        }
+        
+        // Parse first block of list, throwing away its first line (signature)
+        SourceData content;
+        SourceData signature = GetListItemSignature(cur, section.bounds.second, content);
+        
+        // Retrieve any extra lines after signature & warn
+        if (!content.empty()) {
+            
+            data = content;
+            
+            // WARN: not a preformatted code block
+            std::stringstream ss;
+            
+            size_t level = CodeBlockIndentationLevel(section);
+            ss << SectionName(section.type) << " 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";
+            
+            BlockIterator nameBlock = ListItemNameBlock(sectionCur, section.bounds.second);
+            SourceCharactersBlock sourceBlock = CharacterMapForBlock(nameBlock, cur, section.bounds, parser.sourceData);
+            result.first.warnings.push_back(Warning(ss.str(),
+                                                    IndentationWarning,
+                                                    sourceBlock));
+        }
+        
+        sectionCur = FirstContentBlock(cur, section.bounds.second);
+        sourceMap = sectionCur->sourceMap;
+        
+        if (sectionCur != section.bounds.second)
+            result.second = ++sectionCur;
+        
+        return result;
+    }
+}
+
+#endif