redsnow 0.0.8

data/ext/snowcrash/src/StringUtility.h

@@ -0,0 +1,109 @@
+//
+//  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_TRIMSTRING_H
+#define SNOWCRAH_TRIMSTRING_H
+
+#include <algorithm>
+#include <functional>
+#include <cctype>
+#include <locale>
+#include <string>
+#include <sstream>
+#include <vector>
+
+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));
+    }
+    
+    // Retrieve first line of given string
+    inline std::string GetFirstLine(const std::string& s) {
+        std::string::size_type pos = s.find("\n");
+        if (pos == std::string::npos)
+            return s;
+        else
+            return s.substr(0, pos);
+    }
+    
+    // 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;
+    }
+    
+    
+    /**
+     *  \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;
+    }
+}
+
+#endif

data/ext/snowcrash/src/SymbolTable.h

@@ -0,0 +1,83 @@
+//
+//  SymbolTable.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 6/9/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SYMBOLTABLE_H
+#define SNOWCRASH_SYMBOLTABLE_H
+
+#include <string>
+#include <map>
+#include "RegexMatch.h"
+
+#ifdef DEBUG
+#include <iostream>
+#include "Serialize.h"
+#endif
+
+#include "Blueprint.h"
+#include "StringUtility.h"
+
+// Symbol identifier regex
+#define SYMBOL_IDENTIFIER "([^][()]+)"
+
+namespace snowcrashconst {
+    
+    /** Symbol reference matching regex */
+    const char* const SymbolReferenceRegex("^[[:blank:]]*\\[" SYMBOL_IDENTIFIER "]\\[][[:blank:]]*$");
+}
+
+namespace snowcrash {
+
+    // Name of a symbol
+    typedef SourceData SymbolName;
+    
+    // Resource Object Symbol
+    typedef std::pair<SymbolName, ResourceModel> ResourceModelSymbol;
+    
+    // Resource Object Symbol Table
+    typedef std::map<SymbolName, ResourceModel> ResourceModelSymbolTable;
+    
+    struct SymbolTable {
+        
+        // Resource Object Symbol Table
+        ResourceModelSymbolTable resourceModels;
+    };
+    
+    
+    // Checks whether given source data represents reference to a symbol returning true if so,
+    // false otherwise. If source data is represent reference referred symbol name is filled in.
+    FORCEINLINE bool GetSymbolReference(const SourceData& sourceData,
+                                        SymbolName& referredSymbol) {
+        
+        CaptureGroups captureGroups;
+        if (RegexCapture(sourceData, snowcrashconst::SymbolReferenceRegex, captureGroups, 3)) {
+            referredSymbol = captureGroups[1];
+            TrimString(referredSymbol);
+            return true;
+        }
+        return false;
+    }
+    
+#ifdef DEBUG
+    // Prints markdown block recursively to stdout
+    FORCEINLINE void PrintSymbolTable(const SymbolTable& symbolTable) {
+
+        std::cout << "Resource Model Symbols:\n";
+        for (ResourceModelSymbolTable::const_iterator it = symbolTable.resourceModels.begin();
+             it != symbolTable.resourceModels.end();
+             ++it) {
+            
+            std::cout << "- " << it->first << " - body: '" << EscapeNewlines(it->second.body) << "'\n";
+        }
+        
+        std::cout << std::endl;
+    }
+#endif
+    
+}
+
+#endif

data/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 SourceCharactersBlock& 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.result.warnings.push_back(Warning("The URI template contains mismatched expression brackets", URIWarning, sourceBlock));
+            return;
+        }
+       
+        if (HasNestedCurlyBrackets(result.path)) {
+            result.result.warnings.push_back(Warning("The URI template contains nested expression brackets", URIWarning, sourceBlock));
+            return;
+        }
+
+        if (PathContainsSquareBrackets(result.path)) {
+            result.result.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.result.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.result.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.result.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.result.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    }
+                }
+            }
+            else{
+                result.result.warnings.push_back(Warning(classifiedExpression.unsupportedWarningText, URIWarning, sourceBlock));
+            }
+            currentExpression++;
+        }
+    }
+    else{
+        result.result.error = Error("Failed to parse URI Template", URIWarning);
+    }
+
+}
+

data/ext/snowcrash/src/UriTemplateParser.h

@@ -0,0 +1,243 @@
+//
+//  UriTemplateTeParser.h
+//  snowcrash
+//
+//  Created by Carl Griffiths 24/02/2014.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_H
+#define SNOWCRASH_H
+
+#include <string>
+#include "Blueprint.h"
+#include "Parser.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;
+        
+        Result result;
+    };
+    
+    /**
+    *  \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;
+        }
+                
+        FORCEINLINE bool ContainsSpaces() {
+            return innerExpression.find(" ") != std::string::npos;
+        }
+
+        FORCEINLINE bool ContainsAssignment() {
+            return innerExpression.find("=") != std::string::npos;
+        }
+
+        FORCEINLINE bool ContainsHyphens() {
+            return innerExpression.find("-") != std::string::npos;
+        }
+
+        FORCEINLINE 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);
+        }
+
+        FORCEINLINE 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 SourceCharactersBlock& sourceBlock, ParsedURITemplate& result);
+    };
+}
+
+#endif