lounge_lizard 0.1.0

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

@@ -0,0 +1,276 @@
+//
+//  CodeBlockUtility.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 11/10/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_CODEBLOCKUTILITY_H
+#define SNOWCRASH_CODEBLOCKUTILITY_H
+
+#include <sstream>
+#include "Section.h"
+#include "StringUtility.h"
+
+namespace snowcrash {
+
+    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;
+            }
+        }
+
+        /**
+         *  \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) {
+
+            checkPossibleReference(node, pd, report);
+
+            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";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+            report.warnings.push_back(Warning(ss.str(),
+                                              IndentationWarning,
+                                              sourceMap));
+        }
+
+        /** \brief  Retrieve the textual content of a signature markdown */
+        static void signatureContentAsCodeBlock(const MarkdownNodeIterator& node,
+                                                const SectionParserData& pd,
+                                                Report& report,
+                                                mdp::ByteBuffer& content) {
+
+            mdp::ByteBuffer remainingContent;
+            GetFirstLine(node->text, remainingContent);
+
+            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 << 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";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+            report.warnings.push_back(Warning(ss.str(),
+                                              IndentationWarning,
+                                              sourceMap));
+        }
+
+        /**
+         *  \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 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.sourceCharacterIndex);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IndentationWarning,
+                                                  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) {
+
+            std::vector<std::string> rawMetadata = SplitOnFirst(line, ':');
+            if (rawMetadata.size() != 2)
+                return false;
+
+            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
+         *  \param  outSM The source map to which source map should be added
+         *  \return asset The value of the asset
+         */
+        static mdp::ByteBuffer 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);
+            }
+
+            TwoNewLines(asset);
+            out += asset;
+
+            size_t level = CodeBlockUtility::codeBlockIndentationLevel(sectionType);
+
+            if (node->type == mdp::CodeMarkdownNodeType)
+                level--;  // Deduct one level for a code block
+
+            checkPossibleReference(node, pd, report);
+
+            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.sourceCharacterIndex);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IndentationWarning,
+                                                  sourceMap));
+            }
+
+            return asset;
+        }
+
+        /**
+         *  \brief Check for potential resource model reference and warn about not recognizing them
+         *  \return True if code block contains a resource model reference, false otherwise.
+         */
+        static bool checkPossibleReference(const MarkdownNodeIterator& node,
+                                           const SectionParserData& pd,
+                                           Report& report) {
+
+            mdp::ByteBuffer source = node->text;
+            Identifier symbol;
+
+            TrimString(source);
+
+            if(GetModelReference(source, symbol)) {
+
+                std::stringstream ss;
+                ss << "found a possible '" << symbol << "' model reference, ";
+                ss << "a reference must be directly in the " << SectionName(pd.sectionContext()) << " section, indented by 4 spaces or 1 tab, without any additional sections";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                report.warnings.push_back(Warning(ss.str(),
+                                                  IgnoringWarning,
+                                                  sourceMap));
+
+                return true;
+            }
+
+            return false;
+        }
+    };
+}
+
+#endif

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

@@ -0,0 +1,157 @@
+//
+//  DataStructureGroupParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 02/12/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_DATASTRUCTUREGROUPPARSER_H
+#define SNOWCRASH_DATASTRUCTUREGROUPPARSER_H
+
+#include "MSONNamedTypeParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** Data structure group matching regex */
+    const char* const DataStructureGroupRegex = "^[[:blank:]]*[Dd]ata[[:blank:]]+[Ss]tructures?[[:blank:]]*$";
+
+    /**
+     * Data structure group section processor
+     */
+    template<>
+    struct SectionProcessor<DataStructureGroup> : public SectionProcessorBase<DataStructureGroup> {
+
+        NO_SECTION_DESCRIPTION(DataStructureGroup)
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<DataStructureGroup>& out) {
+
+            MarkdownNodeIterator cur = node;
+
+            if (pd.sectionContext() == MSONNamedTypeSectionType) {
+
+                IntermediateParseResult<mson::NamedType> namedType(out.report);
+                cur = MSONNamedTypeParser::parse(node, siblings, pd, namedType);
+
+                if (isNamedTypeDuplicate(pd.blueprint, namedType.node.name.symbol.literal)) {
+
+                    // WARN: duplicate named type
+                    std::stringstream ss;
+                    ss << "named type with name '" << namedType.node.name.symbol.literal << "' already exists";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          DuplicateWarning,
+                                                          sourceMap));
+                    return cur;
+                }
+
+                Element element(Element::DataStructureElement);
+                element.content.dataStructure = namedType.node;
+
+                out.node.content.elements().push_back(element);
+
+                if (pd.exportSourceMap()) {
+
+                    SourceMap<Element> elementSM(Element::DataStructureElement);
+
+                    elementSM.content.dataStructure.name = namedType.sourceMap.name;
+                    elementSM.content.dataStructure.typeDefinition = namedType.sourceMap.typeDefinition;
+                    elementSM.content.dataStructure.sections = namedType.sourceMap.sections;
+
+                    out.sourceMap.content.elements().collection.push_back(elementSM);
+                }
+            }
+
+            return cur;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<DataStructureGroup>& out) {
+
+            out.node.element = Element::CategoryElement;
+            out.node.category = Element::DataStructureGroupCategory;
+
+            if (pd.exportSourceMap()) {
+
+                out.sourceMap.element = out.node.element;
+                out.sourceMap.category = out.node.category;
+            }
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::HeaderMarkdownNodeType &&
+                !node->text.empty()) {
+
+                mdp::ByteBuffer remaining, subject = node->text;
+
+                subject = GetFirstLine(subject, remaining);
+                TrimString(subject);
+
+                if (RegexMatch(subject, DataStructureGroupRegex)) {
+                    return DataStructureGroupSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            return SectionProcessor<mson::NamedType>::sectionType(node);
+        }
+
+        static SectionTypes upperSectionTypes() {
+            return {DataStructureGroupSectionType, ResourceGroupSectionType, ResourceSectionType};
+        }
+
+        /**
+         * \brief Check if a named type already exists with the given name
+         *
+         * \param blueprint The blueprint which is formed until now
+         * \param name The named type name to be checked
+         */
+        static bool isNamedTypeDuplicate(const Blueprint& blueprint,
+                                         mdp::ByteBuffer& name) {
+
+            for (Elements::const_iterator it = blueprint.content.elements().begin();
+                 it != blueprint.content.elements().end();
+                 ++it) {
+
+                if (it->element == Element::CategoryElement) {
+
+                    for (Elements::const_iterator subIt = it->content.elements().begin();
+                         subIt != it->content.elements().end();
+                         ++subIt) {
+
+                        if (subIt->element == Element::ResourceElement &&
+                            subIt->content.resource.attributes.name.symbol.literal == name) {
+
+                            return true;
+                        }
+
+                        if (subIt->element == Element::DataStructureElement &&
+                            subIt->content.dataStructure.name.symbol.literal == name) {
+
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+    };
+
+    /** Data Structures Parser */
+    typedef SectionParser<DataStructureGroup, HeaderSectionAdapter> DataStructureGroupParser;
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/HTTP.cc

@@ -0,0 +1,49 @@
+//
+//  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 HTTPHeaderName::SetCookie = "Set-Cookie";
+const std::string HTTPHeaderName::Link = "Link";
+
+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/drafter/ext/snowcrash/src/HTTP.h

@@ -0,0 +1,108 @@
+//
+//  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;
+
+        static const std::string SetCookie;
+        static const std::string Link;
+    };
+
+    /**
+     * 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