lounge_lizard 0.1.0

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

@@ -0,0 +1,166 @@
+//
+//  SourceAnnotation.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/12/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SOURCEANNOTATION_H
+#define SNOWCRASH_SOURCEANNOTATION_H
+
+#include <string>
+#include <vector>
+#include "ByteBuffer.h"
+
+namespace snowcrash {
+
+
+    /**
+     *  \brief  A source data annotation.
+     *
+     *  Annotation bound to a source data block. Includes an
+     *  annotation code and an optional message.
+     */
+    struct SourceAnnotation {
+
+        /**
+         *  \brief Default annotation code representing success.
+         */
+        static const int OK;
+
+        /**
+         *  \brief  %SourceAnnotation default constructor.
+         *
+         *  Creates an empty annotation with the default annotation code.
+         */
+        SourceAnnotation() : code(OK) {}
+
+        /**
+         *  \brief  %SourceAnnotation copy constructor.
+         *  \param  rhs  An annotation to be copied.
+         */
+        SourceAnnotation(const SourceAnnotation& rhs) {
+
+            this->message = rhs.message;
+            this->code = rhs.code;
+            this->location = rhs.location;
+        }
+
+        /**
+         *  \brief  %SourceAnnotation constructor.
+         *  \param  message     An annotation message.
+         *  \param  code        Annotation code.
+         *  \param  location    A location of the annotation.
+         */
+        SourceAnnotation(const std::string& message,
+                         int code = OK,
+                         const mdp::CharactersRangeSet& location = mdp::CharactersRangeSet()) {
+
+            this->message = message;
+            this->code = code;
+
+            this->location.clear();
+            if (!location.empty())
+                this->location.assign(location.begin(), location.end());
+        }
+
+        /** \brief  %SourceAnnotation destructor. */
+        ~SourceAnnotation() {}
+
+        /**
+         *  \brief  %SourceAnnotation assignment operator
+         *  \param  rhs  An annotation to be assigned to this annotation.
+         */
+        SourceAnnotation& operator=(const SourceAnnotation& rhs) {
+            this->message = rhs.message;
+            this->code = rhs.code;
+            this->location = rhs.location;
+            return *this;
+        }
+
+        /** The location of this annotation within the source data buffer. */
+        mdp::CharactersRangeSet location;
+
+        /** An annotation code. */
+        int code;
+
+        /** A annotation message. */
+        std::string message;
+    };
+
+    /**
+     *  Error source annotation.
+     */
+    typedef SourceAnnotation Error;
+
+    /**
+     *  Error codes
+     */
+    enum ErrorCode {
+        NoError = 0,
+        ApplicationError = 1,
+        BusinessError = 2,
+        ModelError = 3,
+        MSONError = 4
+    };
+
+    /**
+     *  Warning source annotation.
+     */
+    typedef SourceAnnotation Warning;
+
+    /**
+     *  Warning codes
+     */
+    enum WarningCode {
+        NoWarning = 0,
+        APINameWarning = 1,
+        DuplicateWarning = 2,
+        FormattingWarning = 3,
+        RedefinitionWarning = 4,
+        IgnoringWarning = 5,
+        EmptyDefinitionWarning = 6,
+        NotEmptyDefinitionWarning = 7,
+        LogicalErrorWarning = 8,
+        DeprecatedWarning = 9,
+        IndentationWarning = 10,
+        AmbiguityWarning = 11,
+        URIWarning = 12,
+        HTTPWarning = 13
+    };
+
+    /**
+     *  A set of warning source annotations.
+     */
+    typedef std::vector<Warning> Warnings;
+
+    /**
+     *  \brief A parsing report Report.
+     *
+     *  Result of a source data parsing operation.
+     *  Composed of ONE error source annotation
+     *  and a set of warning source annotations.
+     */
+    struct Report {
+
+        /**
+         *  \brief Append a report to this one, replacing the error source annotation.
+         *
+         *  NOTE: A binding does not need to wrap this action.
+         */
+        Report& operator+=(const Report& rhs) {
+            error = rhs.error;
+            warnings.insert(warnings.end(), rhs.warnings.begin(), rhs.warnings.end());
+            return *this;
+        }
+
+        /** Result error source annotation */
+        Error error;
+
+        /** Result warning source annotations */
+        Warnings warnings;
+    };
+}
+
+#endif

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

@@ -0,0 +1,323 @@
+//
+//  TrimString.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/11/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+//  Credits:
+//  http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
+
+#ifndef SNOWCRAH_STRINGUTILITY_H
+#define SNOWCRAH_STRINGUTILITY_H
+
+#include <algorithm>
+#include <functional>
+#include <cctype>
+#include <locale>
+#include <string>
+#include <sstream>
+#include <vector>
+#include "RegexMatch.h"
+#include "MarkdownParser.h"
+
+namespace snowcrash {
+
+    // Check a character not to be an space of any kind
+    inline bool isSpace(const std::string::value_type i){
+        if(i == ' ' || i == '\t' || i == '\n' || i == '\v' || i == '\f' || i == '\r')
+            return true;
+        return false;
+    }
+
+    // Trim string from start
+    inline std::string& TrimStringStart(std::string &s) {
+        s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun(isSpace))));
+        return s;
+    }
+
+    // Trim string from end
+    inline std::string& TrimStringEnd(std::string &s) {
+        s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun(isSpace))).base(), s.end());
+        return s;
+    }
+
+    // Trim both ends of string
+    inline std::string& TrimString(std::string &s) {
+        return TrimStringStart(TrimStringEnd(s));
+    }
+
+
+    // <position form begin, lenght of string>
+    typedef std::tuple<std::string::const_iterator::difference_type, std::string::const_iterator::difference_type> TrimRange;
+
+    // Get Trim Info
+    inline TrimRange GetTrimInfo(std::string::const_iterator begin, std::string::const_iterator end) {
+        std::string::const_reverse_iterator rbegin(end);
+        std::string::const_reverse_iterator rend(begin);
+
+        std::string::const_iterator trim = std::find_if(begin, end, std::not1(std::ptr_fun(isSpace)));
+        std::string::const_reverse_iterator rtrim = std::find_if(rbegin, rend, std::not1(std::ptr_fun(isSpace)));
+
+        return std::make_tuple(std::distance(begin, trim),
+                std::distance(rtrim, std::string::const_reverse_iterator(trim)));
+    }
+
+    // Split string by delim
+    inline std::vector<std::string>& Split(const std::string& s, char delim, std::vector<std::string>& elems) {
+        std::stringstream ss(s);
+        std::string item;
+        while (std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+        return elems;
+    }
+
+    // Split string by delim
+    inline std::vector<std::string> Split(const std::string& s, char delim) {
+        std::vector<std::string> elems;
+        Split(s, delim, elems);
+        return elems;
+    }
+
+    // Split string on the first occurrence of delim
+    inline std::vector<std::string> SplitOnFirst(const std::string& s, char delim) {
+        std::string::size_type pos = s.find(delim);
+        std::vector<std::string> elems;
+        if (pos == std::string::npos) {
+            elems.push_back(s);
+        }
+        else {
+            elems.push_back(s.substr(0, pos));
+            elems.push_back(s.substr(pos + 1, std::string::npos));
+        }
+        return elems;
+    }
+
+    // Make sure last two characters are newlines
+    inline std::string& TwoNewLines(std::string& s) {
+
+        if (s[s.length() - 1] != '\n') {
+            s += "\n";
+        }
+
+        if (s[s.length() - 2] != '\n') {
+            s += "\n";
+        }
+
+        return s;
+    }
+
+    /**
+     *  \brief  Replace all occurrences of a string.
+     *  \param  s       A string to search in.
+     *  \param  find    A string to look for.
+     *  \param  replace A string to replace with.
+     *  \return A copy of %s with all occurrences of %find replaced by %replace.
+     */
+    inline std::string ReplaceString(const std::string& s,
+                                     const std::string& find,
+                                     const std::string& replace) {
+        size_t pos = 0;
+        std::string target(s);
+        while ((pos = target.find(find, pos)) != std::string::npos) {
+            target.replace(pos, find.length(), replace);
+            pos += replace.length();
+        }
+        return target;
+    }
+
+    /**
+     *  \brief  Extract the first line from a string.
+     *
+     *  \param  s   Subject of the extraction
+     *  \param  r   Remaining content aftert the extraction
+     *  \return First line from the subject string
+     */
+    inline std::string GetFirstLine(const std::string& s, std::string& r){
+        std::vector<std::string> elem = SplitOnFirst(s, '\n');
+        if (elem.empty())
+            return std::string();
+        if (elem.size() > 1)
+            r = elem.back();
+        return elem.front();
+    }
+
+    /**
+     *  \brief  compare equality  - allow compare diferent types
+     *
+     *  \return true if args era equal
+     */
+    struct IsEqual {
+        template<typename T1, typename T2>
+            bool operator()(const T1& a1, const T2& a2) const {
+                return a1 == a2;
+            }
+    };
+
+    /**
+     *  \brief  compare equality - character are compare case insensitive
+     *
+     *  \return true if args era equal
+     */
+    struct IsIEqual {
+        template<typename T1, typename T2>
+            bool operator()(const T1& a1, const T2& a2) const {
+                return std::tolower(a1) == std::tolower(a2);
+            }
+    };
+
+    /**
+     *  \brief  compare containers equality
+     *
+     *  \requirements
+     *    - both containers must support methods ::length(), ::begin(), ::end()
+     *    - both containers must be iterable
+     *    - both containers must contain comparable types
+     *
+     *  \param arg1, arg2 - containers to compare
+     *  \param predicate - testing equality
+     *
+     *  \return true if containers contains same content
+     */
+
+    template <typename T1, typename T2, typename Predicate>
+    inline bool MatchContainers(const T1& arg1, const T2& arg2, const Predicate& predicate) {
+        if (arg1.length() != arg2.length()) {
+            return false;
+        }
+        return std::equal(arg1.begin(), arg1.end(), arg2.begin(), predicate);
+    }
+
+    template <typename T>
+    struct Equal : std::binary_function<T, T, bool> {
+        bool operator()(const T& left, const T& right) const {
+            return MatchContainers(left, right, IsEqual());
+        }
+    };
+
+    template <typename T>
+    struct IEqual : std::binary_function<T, T, bool> {
+        bool operator()(const T& left, const T& right) const {
+            return MatchContainers(left, right, IsIEqual());
+        }
+    };
+
+    /**
+     * \brief Retrieve the string enclosed by the given matching escaping characters
+     *
+     *        Please note that the subject will be stripped of the escaped string
+     *        and the characters before it
+     *
+     * \param subject String that needs to be parsed
+     * \param begin Character representing the beginning of the escaped string
+     * \param stripEscapeChars If true, strip the escape characters from the result string
+     *
+     * \return Returns the escaped string
+     *
+     * \example (begin = 1, subject = "a```b```cd") ----> (return = "```b```", subject = "cd")
+     */
+    inline std::string RetrieveEscaped(std::string& subject,
+                                       size_t begin = 0,
+                                       const bool stripEscapeChars = false) {
+
+        size_t levels = 0;
+        const char escapeChar = subject[begin];
+
+        // Get the level of the backticks
+        while (subject[levels + begin] == escapeChar) {
+            levels++;
+        }
+
+        std::string borderChars = subject.substr(begin, levels);
+        size_t end = subject.substr(levels + begin).find(borderChars);
+
+        if (end == std::string::npos) {
+            return "";
+        }
+
+        if (stripEscapeChars) {
+            begin = begin + levels;
+            end = end + begin;
+        } else {
+            end = end + (2 * levels) + begin;
+        }
+
+        std::string escapedString = subject.substr(begin, end - begin);
+        subject = subject.substr(end);
+
+        return escapedString;
+    }
+
+    /**
+     * \brief Strip the enclosing backticks and return the string in the middle.
+     *
+     *        If there are no matching enclosing bacticks, return the whole string.
+     *
+     * \param subject String that needs to be stripped of enclosing backticks
+     *
+     * \return Substring that has been stripped of enclosing backticks
+     */
+    inline std::string StripBackticks(std::string& subject) {
+
+        // Check if first and last chars are backticks
+        if (subject[0] != '`' ||
+            subject[subject.length() - 1] != '`') {
+
+            return subject;
+        }
+
+        std::string escapedString = RetrieveEscaped(subject, 0, true);
+
+        if (escapedString.empty()) {
+            return subject;
+        }
+
+        TrimString(escapedString);
+
+        return escapedString;
+    }
+
+    /**
+     * \brief If the given string is a markdown link, return the string which is being linked
+     *
+     *        If there is no link, return the whole string
+     *
+     * \param subject String which is a markdown link
+     *
+     * \return Substring which is inside the first [] of the markdown link
+     */
+    inline std::string StripMarkdownLink(const std::string& subject) {
+
+        // Check if markdown link
+        if (subject[0] != mdp::MarkdownBeginReference) {
+            return subject;
+        }
+
+        std::string linkedString = RegexCaptureFirst(subject, mdp::MarkdownLinkRegex);
+        TrimString(linkedString);
+
+        return linkedString;
+    }
+
+    inline std::string ReconstructMarkdownHeader(const mdp::MarkdownNode& node) {
+        std::string subject;
+
+        // we are not able to reconstruct correctly headers
+        // there is missing info about spacing on both sides
+        // node.sourceMap - contain length, but we dont now count of space on both sides
+        // it we are not able to distinguis between "a  ", " a " and "  a".
+        //
+        // Solution - we strictly strip whitespace
+
+        if (node.type == mdp::HeaderMarkdownNodeType) {
+            subject.reserve(node.text.length() + node.data -1);
+            subject.append(node.data, '#');
+            subject.append(node.text);
+        }
+
+        return subject;
+    }
+}
+
+#endif

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

@@ -0,0 +1,195 @@
+//
+//  UriTemplateParser.cc
+//  snowcrash
+//
+//  Created by Carl Griffiths on 24/02/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+#include <iomanip>
+#include "UriTemplateParser.h"
+#include "RegexMatch.h"
+
+using namespace snowcrash;
+
+static bool HasMismatchedCurlyBrackets(const URITemplate& uriTemplate) {
+    int openCount = 0;
+    int closeCount = 0;
+
+    for (unsigned int i = 0; i < uriTemplate.length(); i++) {
+        if (uriTemplate[i] == '{') openCount++;
+        if (uriTemplate[i] == '}') closeCount++;
+    }
+    return openCount != closeCount;
+}
+
+static bool HasNestedCurlyBrackets(const URITemplate& uriTemplate) {
+    char lastBracket = ' ';
+    bool result = false;
+
+    for (unsigned int i = 0; i < uriTemplate.length(); i++) {
+        if (uriTemplate[i] == '{') {
+            if (lastBracket == '{') {
+                result = true;
+                break;
+            }
+            lastBracket = '{';
+        }
+        if (uriTemplate[i] == '}') {
+            if (lastBracket == '}') {
+                result = true;
+                break;
+            }
+            lastBracket = '}';
+        }
+    }
+    return result;
+}
+
+static bool PathContainsSquareBrackets(const URITemplate& uriTemplate) {
+    return (uriTemplate.find('[') != std::string::npos || uriTemplate.find(']') != std::string::npos);
+}
+
+static Expressions GetUriTemplateExpressions(const URITemplate& uriTemplate) {
+    Expressions expressions;
+    size_t expressionStartPos = 0;
+    size_t expressionEndPos = 0;
+
+    while (expressionStartPos != std::string::npos && expressionEndPos != std::string::npos && expressionStartPos < uriTemplate.length()) {
+        expressionStartPos = uriTemplate.find("{", expressionStartPos);
+        expressionEndPos = uriTemplate.find("}", expressionStartPos);
+        if (expressionStartPos != std::string::npos && expressionEndPos > expressionStartPos) {
+            expressions.push_back(uriTemplate.substr(expressionStartPos + 1, (expressionEndPos - expressionStartPos) - 1));
+        }
+        expressionStartPos++;
+    }
+    return expressions;
+}
+
+
+static ClassifiedExpression ClassifyExpression(const Expression& expression) {
+
+    VariableExpression variableExpression(expression);
+
+    if (variableExpression.IsExpressionType()) {
+        return variableExpression;
+    }
+
+    QueryStringExpression queryStringExpression(expression);
+    if (queryStringExpression.IsExpressionType()) {
+        return queryStringExpression;
+    }
+
+    FragmentExpression fragmentExpression(expression);
+    if (fragmentExpression.IsExpressionType()) {
+        return fragmentExpression;
+    }
+
+    ReservedExpansionExpression reservedExpansionExpression(expression);
+    if (reservedExpansionExpression.IsExpressionType()) {
+        return reservedExpansionExpression;
+    }
+
+    LabelExpansionExpression labelExpansionExpression(expression);
+    if (labelExpansionExpression.IsExpressionType()) {
+        return labelExpansionExpression;
+    }
+
+    PathSegmentExpansionExpression pathSegmentExpansionExpression(expression);
+    if (pathSegmentExpansionExpression.IsExpressionType()) {
+        return pathSegmentExpansionExpression;
+    }
+
+    PathStyleParameterExpansionExpression pathStyleParameterExpansionExpression(expression);
+    if (pathStyleParameterExpansionExpression.IsExpressionType()) {
+        return pathSegmentExpansionExpression;
+    }
+
+    FormStyleQueryContinuationExpression formStyleQueryContinuationExpression(expression);
+    if (formStyleQueryContinuationExpression.IsExpressionType()) {
+        return formStyleQueryContinuationExpression;
+    }
+
+    UndefinedExpression undefinedExpression(expression);
+
+    return undefinedExpression;
+}
+
+void URITemplateParser::parse(const URITemplate& uri, const mdp::CharactersRangeSet& sourceBlock, ParsedURITemplate& result)
+{
+    CaptureGroups groups;
+    Expressions expressions;
+    size_t gSize=5;
+
+    if (uri.empty()) return;
+
+    if (RegexCapture(uri, URI_REGEX, groups, gSize)) {
+        result.scheme = groups[1];
+        result.host = groups[3];
+        result.path = groups[4];
+
+        if (HasMismatchedCurlyBrackets(result.path)) {
+            result.report.warnings.push_back(Warning("The URI template contains mismatched expression brackets", URIWarning, sourceBlock));
+            return;
+        }
+
+        if (HasNestedCurlyBrackets(result.path)) {
+            result.report.warnings.push_back(Warning("The URI template contains nested expression brackets", URIWarning, sourceBlock));
+            return;
+        }
+
+        if (PathContainsSquareBrackets(result.path)) {
+            result.report.warnings.push_back(Warning("The URI template contains square brackets, please percent encode square brackets as %5B and %5D", URIWarning, sourceBlock));
+        }
+
+        expressions = GetUriTemplateExpressions(result.path);
+
+        ExpressionIterator currentExpression = expressions.begin();
+
+        while (currentExpression != expressions.end()) {
+
+            ClassifiedExpression classifiedExpression = ClassifyExpression(*currentExpression);
+
+            if (classifiedExpression.IsSupportedExpressionType()) {
+                bool hasIllegalCharacters = false;
+
+                if (classifiedExpression.ContainsSpaces()) {
+                    std::stringstream ss;
+                    ss << "URI template expression \"" << classifiedExpression.innerExpression << "\" contains spaces. Allowed characters for expressions are A-Z a-z 0-9 _ and percent encoded characters";
+                    result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    hasIllegalCharacters = true;
+                }
+
+                if (classifiedExpression.ContainsHyphens()) {
+                    std::stringstream ss;
+                    ss << "URI template expression \"" << classifiedExpression.innerExpression << "\" contains hyphens. Allowed characters for expressions are A-Z a-z 0-9 _ and percent encoded characters";
+                    result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    hasIllegalCharacters = true;
+                }
+
+                if (classifiedExpression.ContainsAssignment()) {
+                    std::stringstream ss;
+                    ss << "URI template expression \"" << classifiedExpression.innerExpression << "\" contains assignment. Allowed characters for expressions are A-Z a-z 0-9 _ and percent encoded characters";
+                    result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    hasIllegalCharacters = true;
+                }
+
+                if (!hasIllegalCharacters) {
+                    if (classifiedExpression.IsInvalidExpressionName()) {
+                        std::stringstream ss;
+                        ss << "URI template expression \"" << classifiedExpression.innerExpression << "\" contains invalid characters. Allowed characters for expressions are A-Z a-z 0-9 _ and percent encoded characters";
+                        result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    }
+                }
+            }
+            else{
+                result.report.warnings.push_back(Warning(classifiedExpression.unsupportedWarningText, URIWarning, sourceBlock));
+            }
+            currentExpression++;
+        }
+    }
+    else{
+        result.report.error = Error("Failed to parse URI Template", ApplicationError);
+    }
+
+}
+