lounge_lizard 0.1.0

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

@@ -0,0 +1,240 @@
+//
+//  UriTemplateTeParser.h
+//  snowcrash
+//
+//  Created by Carl Griffiths 24/02/2014.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_URITEMPLATEPARSER_H
+#define SNOWCRASH_URITEMPLATEPARSER_H
+
+#include "Blueprint.h"
+#include "SourceAnnotation.h"
+#include "RegexMatch.h"
+
+#define URI_REGEX "^(http|https|ftp|file)?(://)?([^/]*)?(.*)$"
+#define URI_TEMPLATE_OPERATOR_REGEX "([+|#|.|/|;|?|&])"
+#define URI_TEMPLATE_EXPRESSION_REGEX "^([?|#|+|&]?(([A-Z|a-z|0-9|_|,])*|(%[A-F|a-f|0-9]{2})*)*\\*?)$"
+
+namespace snowcrash {
+
+    /**
+    *  \brief URI template parse result.
+    */
+    struct ParsedURITemplate {
+        std::string scheme;
+        std::string host;
+        std::string path;
+
+        Report report;
+    };
+
+    /**
+    *  \brief URI template expression.
+    */
+    typedef std::string Expression;
+
+    /**
+    *  \brief collection for expressions for a single URI template.
+    */
+    typedef std::vector<Expression> Expressions;
+
+    /**
+    *  \brief iterator for collection of expressions.
+    */
+    typedef std::vector<Expression>::const_iterator ExpressionIterator;
+
+    /**
+    *  \brief base class for URI template expression once classified.
+    */
+    class ClassifiedExpression {
+    protected :
+        bool isSupported;
+    public :
+        ClassifiedExpression(const std::string& expression) {
+            isSupported = false;
+            unsupportedWarningText = "";
+            innerExpression = expression;
+        }
+
+        std::string unsupportedWarningText;
+
+        snowcrash::Expression innerExpression;
+
+        virtual bool IsExpressionType() const {
+            return false;
+        }
+
+        bool ContainsSpaces() {
+            return innerExpression.find(" ") != std::string::npos;
+        }
+
+        bool ContainsAssignment() {
+            return innerExpression.find("=") != std::string::npos;
+        }
+
+        bool ContainsHyphens() {
+            return innerExpression.find("-") != std::string::npos;
+        }
+
+        bool IsInvalidExpressionName() {
+            std::string tmpExpression = innerExpression;
+            if (tmpExpression.find("..") != std::string::npos) return true;
+
+            size_t start_pos = 0;
+            while ((start_pos = tmpExpression.find(".", start_pos)) != std::string::npos) {
+                tmpExpression.replace(start_pos, 1, "_");
+                start_pos++;
+            }
+
+            return !RegexMatch(tmpExpression, URI_TEMPLATE_EXPRESSION_REGEX);
+        }
+
+        bool IsSupportedExpressionType() {
+            return isSupported;
+        }
+    };
+
+    /**
+    *  \brief level one basic variable expansion URI template expression.
+    */
+    class VariableExpression : public ClassifiedExpression {
+    public :
+        VariableExpression(const std::string& expression):ClassifiedExpression(expression) {
+            isSupported = true;
+        }
+
+        bool IsExpressionType() const {
+            return !RegexMatch(innerExpression.substr(0, 1), URI_TEMPLATE_OPERATOR_REGEX);
+        }
+    };
+
+    /**
+    *  \brief level three query string expansion URI template expression.
+    */
+    class QueryStringExpression : public ClassifiedExpression {
+    public :
+        QueryStringExpression(const std::string& expression):ClassifiedExpression(expression) {
+            isSupported =  true;
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == "?";
+        }
+    };
+
+    /**
+    *  \brief level two fragment expansion URI template expression.
+    */
+    class FragmentExpression : public ClassifiedExpression {
+    public :
+        FragmentExpression(const std::string& expression):ClassifiedExpression(expression) {
+            isSupported = true;
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == "#";
+        }
+    };
+
+    /**
+    *  \brief level two reserved expansion URI template expression.
+    */
+    class ReservedExpansionExpression : public ClassifiedExpression {
+    public :
+        ReservedExpansionExpression(const std::string& expression):ClassifiedExpression(expression) {
+            isSupported = true;
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == "+";
+        }
+    };
+
+    /**
+    *  \brief level three label expansion URI template expression.
+    */
+    class LabelExpansionExpression : public ClassifiedExpression {
+    public :
+        LabelExpansionExpression(const std::string& expression):ClassifiedExpression(expression) {
+            unsupportedWarningText = "URI template label expansion is not supported";
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == ".";
+        }
+    };
+
+    /**
+    *  \brief level three path segment expansion URI template expression.
+    */
+    class PathSegmentExpansionExpression : public ClassifiedExpression {
+    public :
+        PathSegmentExpansionExpression(const std::string& expression):ClassifiedExpression(expression) {
+            unsupportedWarningText = "URI template path segment expansion is not supported";
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == "/";
+        }
+    };
+
+    /**
+    *  \brief level three path style parameter expansion URI template expression.
+    */
+    class PathStyleParameterExpansionExpression : public ClassifiedExpression {
+    public :
+        PathStyleParameterExpansionExpression(const std::string& expression):ClassifiedExpression(expression) {
+            unsupportedWarningText = "URI template path style parameter expansion is not supported";
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == ";";
+        }
+    };
+
+    /**
+    *  \brief level three form style query continuation expansion URI template expression.
+    */
+    class FormStyleQueryContinuationExpression : public ClassifiedExpression {
+    public :
+        FormStyleQueryContinuationExpression(const std::string& expression):ClassifiedExpression(expression) {
+            isSupported = true;
+        }
+
+        bool IsExpressionType() const {
+            return innerExpression.substr(0, 1) == "&";
+        }
+    };
+
+    /**
+    *  \brief undefined URI template expression.
+    */
+    class UndefinedExpression : public ClassifiedExpression{
+    public :
+        UndefinedExpression(const std::string& expression) :ClassifiedExpression(expression) {
+            unsupportedWarningText = "Unidentified expression";
+        }
+
+        bool IsExpressionType() const {
+            return false;
+        }
+    };
+
+    /**
+    *  URI Template Parser Interface
+    *  ------------------------------
+    */
+    class URITemplateParser{
+    public :
+        /**
+        *  \brief Parse the URI template into scheme, host and path and then parse for supported URI template expressions
+        *
+        *  \param uri        A uri to be parsed.
+        */
+        static void parse(const URITemplate& uri, const mdp::CharactersRangeSet& sourceBlock, ParsedURITemplate& result);
+    };
+}
+
+#endif

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

@@ -0,0 +1,111 @@
+//
+//  ValuesParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 6/12/14
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_VALUESPARSER_H
+#define SNOWCRASH_VALUESPARSER_H
+
+#include "SectionParser.h"
+#include "RegexMatch.h"
+#include "StringUtility.h"
+
+/** Parameter Value regex */
+#define PARAMETER_VALUE "`([^`]+)`"
+
+namespace snowcrash {
+
+    /** Parameter Values matching regex */
+    const char* const ValuesRegex = "^[[:blank:]]*[Vv]alues[[:blank:]]*$";
+
+    /**
+     * Values section processor
+     */
+    template<>
+    struct SectionProcessor<Values> : public SectionProcessorBase<Values> {
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<Values>& out) {
+
+            if (pd.sectionContext() == ValueSectionType) {
+
+                mdp::ByteBuffer content = node->children().front().text;
+                CaptureGroups captureGroups;
+
+                RegexCapture(content, PARAMETER_VALUE, captureGroups);
+
+                if (captureGroups.size() > 1) {
+                    out.node.push_back(captureGroups[1]);
+
+                    if (pd.exportSourceMap()) {
+                        SourceMap<Value> valueSM;
+                        valueSM.sourceMap = node->sourceMap;
+                        out.sourceMap.collection.push_back(valueSM);
+                    }
+                } else {
+                    TrimString(content);
+
+                    // WARN: Ignoring the unexpected param value
+                    std::stringstream ss;
+                    ss << "ignoring the '" << content << "' element";
+                    ss << ", expected '`" << content << "`'";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          IgnoringWarning,
+                                                          sourceMap));
+                }
+
+                return ++MarkdownNodeIterator(node);
+            }
+
+            return node;
+        }
+
+        NO_SECTION_DESCRIPTION(Values)
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                mdp::ByteBuffer subject = node->children().front().text;
+                TrimString(subject);
+
+                if (RegexMatch(subject, ValuesRegex)) {
+                    return ValuesSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                mdp::ByteBuffer subject = node->children().front().text;
+                TrimString(subject);
+
+                if (node->children().size() == 1 &&
+                    !subject.empty()) {
+
+                    return ValueSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+    };
+
+    /** Parameter Section Parser */
+    typedef SectionParser<Values, ListSectionAdapter> ValuesParser;
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/posix/RegexMatch.cc

@@ -0,0 +1,99 @@
+//
+//  RegexMatch.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <regex.h>
+#include <cstring>
+#include "../RegexMatch.h"
+
+// FIXME: Migrate to C++11.
+// Naive implementation of regex matching using POSIX regex
+bool snowcrash::RegexMatch(const std::string& target, const std::string& expression)
+{
+    if (target.empty() || expression.empty())
+        return false;
+
+    regex_t regex;
+    int reti = ::regcomp(&regex, expression.c_str(), REG_EXTENDED | REG_NOSUB);
+    if (reti) {
+        // Unable to compile regex
+        return false;
+    }
+    
+    // Execute regular expression
+    reti = ::regexec(&regex, target.c_str(), 0, NULL, 0);
+    if (!reti) {
+        ::regfree(&regex);
+        return true;
+    }
+    else if (reti == REG_NOMATCH) {
+        ::regfree(&regex);
+        return false;
+    }
+    else {
+        char msgbuf[1024];
+        regerror(reti, &regex, msgbuf, sizeof(msgbuf));
+        ::regfree(&regex);
+        return false;
+    }
+    
+    return false;
+}
+
+std::string snowcrash::RegexCaptureFirst(const std::string& target, const std::string& expression)
+{
+    CaptureGroups groups;
+    if (!RegexCapture(target, expression, groups) ||
+        groups.size() < 2)
+        return std::string();
+    
+    return groups[1];
+}
+
+bool snowcrash::RegexCapture(const std::string& target, const std::string& expression, CaptureGroups& captureGroups, size_t groupSize)
+{
+    if (target.empty() || expression.empty())
+        return false;
+    
+    captureGroups.clear();
+    
+    try {
+        regex_t regex;
+        int reti = ::regcomp(&regex, expression.c_str(), REG_EXTENDED);
+        if (reti)
+            return false;
+        
+        regmatch_t *pmatch = ::new regmatch_t[groupSize];
+        ::memset(pmatch, 0, sizeof(regmatch_t) * groupSize);
+        
+        reti = ::regexec(&regex, target.c_str(), groupSize, pmatch, 0);
+        if (!reti) {
+            ::regfree(&regex);
+            
+            for (size_t i = 0; i < groupSize; ++i) {
+                if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
+                    captureGroups.push_back(std::string());
+                else
+                    captureGroups.push_back(std::string(target, pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so));
+            }
+            
+            delete [] pmatch;
+            return true;
+        }
+        else {
+            ::regfree(&regex);
+            delete [] pmatch;        
+            return false;
+        }
+    }
+    catch (...) {
+    }
+    
+    return false;    
+}
+
+

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

@@ -0,0 +1,90 @@
+//
+//  snowcrash.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "snowcrash.h"
+#include "BlueprintParser.h"
+
+const int snowcrash::SourceAnnotation::OK = 0;
+
+using namespace snowcrash;
+
+/**
+ *  \brief  Check source for unsupported character \t & \r
+ *  \return True if passed (not found), false otherwise
+ */
+static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
+{
+
+    std::string::size_type pos = source.find("\t");
+
+    if (pos != std::string::npos) {
+
+        mdp::BytesRangeSet rangeSet;
+        rangeSet.push_back(mdp::BytesRange(pos, 1));
+        report.error = Error("the use of tab(s) '\\t' in source data isn't currently supported, please contact makers",
+                             BusinessError,
+                             mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
+        return false;
+    }
+
+    pos = source.find("\r");
+
+    if (pos != std::string::npos) {
+
+        mdp::BytesRangeSet rangeSet;
+        rangeSet.push_back(mdp::BytesRange(pos, 1));
+        report.error = Error("the use of carriage return(s) '\\r' in source data isn't currently supported, please contact makers",
+                             BusinessError,
+                             mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
+        return false;
+    }
+
+    return true;
+}
+
+int snowcrash::parse(const mdp::ByteBuffer& source,
+                     BlueprintParserOptions options,
+                     const ParseResultRef<Blueprint>& out)
+{
+    try {
+
+        // Sanity Check
+        if (!CheckSource(source, out.report))
+            return out.report.error.code;
+
+        // Do nothing if blueprint is empty
+        if (source.empty())
+            return out.report.error.code;
+
+        // Parse Markdown
+        mdp::MarkdownParser markdownParser;
+        mdp::MarkdownNode markdownAST;
+        markdownParser.parse(source, markdownAST);
+
+        // Build SectionParserData
+        SectionParserData pd(options, source, out.node);
+        mdp::BuildCharacterIndex(pd.sourceCharacterIndex, source);
+
+        // Parse Blueprint
+        BlueprintParser::parse(markdownAST.children().begin(), markdownAST.children(), pd, out);
+    }
+    catch (const Error& e) {
+        out.report.error = e;
+    }
+    catch (const std::exception& e) {
+
+        std::stringstream ss;
+        ss << "parser exception: '" << e.what() << "'";
+        out.report.error = Error(ss.str(), ApplicationError);
+    }
+    catch (...) {
+        out.report.error = Error("parser exception has occured", ApplicationError);
+    }
+
+    return out.report.error.code;
+}

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

@@ -0,0 +1,44 @@
+//
+//  snowcrash.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/2/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_H
+#define SNOWCRASH_H
+
+#include "BlueprintSourcemap.h"
+#include "SourceAnnotation.h"
+#include "SectionParser.h"
+
+/**
+ *  API Blueprint Parser Interface
+ *  ------------------------------
+ *
+ *  This is the parser's entry point.
+ *
+ *  For Snow Crash users, this is the only interface to use.
+ *
+ *  For binding writers, this is the point to start wrapping.
+ *  Refer to https://github.com/apiaryio/snowcrash/wiki/Writing-a-binding
+ *  for details on how to write a Snow Crash binding.
+ */
+
+namespace snowcrash {
+
+    /**
+     *  \brief Parse the source data into a blueprint abstract source tree (AST).
+     *
+     *  \param source       A textual source data to be parsed.
+     *  \param options      Parser options. Use 0 for no additional options.
+     *  \param out          Output buffer to store parsing result into.
+     *  \return Error status code. Zero represents success, non-zero a failure.
+     */
+    int parse(const mdp::ByteBuffer& source,
+              BlueprintParserOptions options,
+              const ParseResultRef<Blueprint>& out);
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/win/RegexMatch.cc

@@ -0,0 +1,78 @@
+//
+//  RegexMatch.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 7/1/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <regex>
+#include <cstring>
+#include "../RegexMatch.h"
+
+using namespace std;
+
+#if _MSC_VER == 1500
+using namespace std::tr1;
+#endif
+//
+// A C++09 implementation
+//
+
+bool snowcrash::RegexMatch(const string& target, const string& expression)
+{
+    if (target.empty() || expression.empty())
+        return false;
+
+    try {
+        regex pattern(expression, regex_constants::extended);
+        return regex_search(target, pattern);
+    }
+    catch (const regex_error&) {
+    }
+    catch (...) {
+    }
+
+    return false;
+}
+
+string snowcrash::RegexCaptureFirst(const string& target, const string& expression)
+{
+    CaptureGroups groups;
+    if (!RegexCapture(target, expression, groups) ||
+        groups.size() < 2)
+        return string();
+
+    return groups[1];
+}
+
+bool snowcrash::RegexCapture(const string& target, const string& expression, CaptureGroups& captureGroups, size_t groupSize)
+{
+    if (target.empty() || expression.empty())
+        return false;
+
+    captureGroups.clear();
+
+    try {
+
+        regex pattern(expression, regex_constants::extended);
+        match_results<string::const_iterator> result;
+        if (!regex_search(target, result, pattern))
+            return false;
+
+        for (match_results<string::const_iterator>::const_iterator it = result.begin();
+             it != result.end();
+             ++it) {
+
+            captureGroups.push_back(*it);
+        }
+
+        return true;
+    }
+    catch (const regex_error&) {
+    }
+    catch (...) {
+    }
+
+    return false;
+}

data/ext/drafter/ext/snowcrash/tools/gyp/AUTHORS

@@ -0,0 +1,12 @@
+# Names should be added to this file like so:
+# Name or Organization <email address>
+
+Google Inc.
+Bloomberg Finance L.P.
+Yandex LLC
+
+Steven Knight <knight@baldmt.com>
+Ryan Norton <rnorton10@gmail.com>
+David J. Sankel <david@sankelsoftware.com>
+Eric N. Vander Weele <ericvw@gmail.com>
+Tom Freudenberg <th.freudenberg@gmail.com>

data/ext/drafter/ext/snowcrash/tools/gyp/DEPS

@@ -0,0 +1,23 @@
+# DEPS file for gclient use in buildbot execution of gyp tests.
+#
+# (You don't need to use gclient for normal GYP development work.)
+
+vars = {
+  "chromium_git": "https://chromium.googlesource.com/",
+}
+
+deps = {
+}
+
+deps_os = {
+  "win": {
+    "third_party/cygwin":
+      Var("chromium_git") + "chromium/deps/cygwin@4fbd5b9",
+
+    "third_party/python_26":
+      Var("chromium_git") + "chromium/deps/python_26@5bb4080",
+
+    "src/third_party/pefile":
+       Var("chromium_git") + "external/pefile@72c6ae4",
+  },
+}

data/ext/drafter/ext/snowcrash/tools/gyp/OWNERS

@@ -0,0 +1 @@
+*