redsnow 0.1.6 → 0.2.0

data/ext/snowcrash/src/Signature.cc

@@ -0,0 +1,74 @@
+//
+//  Signature.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 6/20/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "Signature.h"
+#include "SectionParser.h"
+#include "ActionParser.h"
+#include "AssetParser.h"
+#include "HeadersParser.h"
+#include "PayloadParser.h"
+#include "ParametersParser.h"
+#include "ResourceParser.h"
+#include "ResourceGroupParser.h"
+
+using namespace snowcrash;
+
+SectionType snowcrash::SectionKeywordSignature(const mdp::MarkdownNodeIterator& node)
+{
+    // Note: Every-keyword defined section should be listed here...
+    SectionType type = UndefinedSectionType;
+
+    if ((type = SectionProcessor<Headers>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    if ((type = SectionProcessor<Asset>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    if ((type = SectionProcessor<Payload>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    if ((type = SectionProcessor<Values>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    if ((type = SectionProcessor<Parameters>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    /* 
+     *  NOTE: Order is important. Resource MUST preceed the Action.
+     *
+     *  This is because an HTTP Request Method + URI is recognized as both %ActionSectionType and %ResourceSectionType.
+     *  This is not optimal and should be addressed in the future.
+     */
+    if ((type = SectionProcessor<Resource>::sectionType(node)) != UndefinedSectionType)
+        return type;
+    
+    if ((type = SectionProcessor<Action>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    if ((type = SectionProcessor<ResourceGroup>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
+    return type;
+}
+
+SectionType snowcrash::RecognizeCodeBlockFirstLine(const mdp::ByteBuffer& subject)
+{
+    SectionType type = UndefinedSectionType;
+
+    if (RegexMatch(subject, HeadersRegex)) {
+        return HeadersSectionType;
+    }
+    else if (RegexMatch(subject, BodyRegex)) {
+        return BodySectionType;
+    }
+    else if (RegexMatch(subject, SchemaRegex)) {
+        return SchemaSectionType;
+    }
+
+    return type;
+}

data/ext/snowcrash/src/Signature.h

@@ -0,0 +1,32 @@
+//
+//  Signature.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/14/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SIGNATURE_H
+#define SNOWCRASH_SIGNATURE_H
+
+#include "MarkdownNode.h"
+#include "Section.h"
+
+namespace snowcrash {
+
+    /** 
+     *  \brief Query whether a node has keyword-defined signature.
+     *  \param node     A Markdown AST node to check.
+     *  \return Type of the node if it has a recognized keyword signature, UndefinedType otherwise
+     */
+    extern SectionType SectionKeywordSignature(const mdp::MarkdownNodeIterator& node);
+
+    /**
+     *  \brief Recognize the type of section given the first line from a code block
+     *  \param subject  The first line that needs to be recognized
+     *  \return SectionType Type of the section if the line contains a keyword
+     */
+    extern SectionType RecognizeCodeBlockFirstLine(const mdp::ByteBuffer& subject);
+}
+
+#endif

data/ext/snowcrash/src/SourceAnnotation.h

@@ -11,23 +11,10 @@
 
 #include <string>
 #include <vector>
+#include "ByteBuffer.h"
 
 namespace snowcrash {
     
-    /**
-     *  \brief  A character range within the source code string.
-     */
-    struct SourceCharactersRange {
-        size_t location;
-        size_t length;
-    };
-    
-    /**
-     *  \brief  A block (set of ranges) of source code characters. A character map.
-     *
-     *  NOTE: The block does not have to be continuous.
-     */
-    typedef std::vector<SourceCharactersRange> SourceCharactersBlock;
     
     /**
      *  \brief  A source data annotation.
@@ -68,7 +55,7 @@ namespace snowcrash {
          */
         SourceAnnotation(const std::string& message,
                          int code = OK,
-                         const SourceCharactersBlock& location = SourceCharactersBlock()) {
+                         const mdp::CharactersRangeSet& location = mdp::CharactersRangeSet()) {
             
             this->message = message;
             this->code = code;
@@ -93,7 +80,7 @@ namespace snowcrash {
         }
         
         /** The location of this annotation within the source data buffer. */
-        SourceCharactersBlock location;
+        mdp::CharactersRangeSet location;
         
         /** An annotation code. */
         int code;
@@ -147,20 +134,20 @@ namespace snowcrash {
     typedef std::vector<Warning> Warnings;
     
     /**
-     *  \brief A parsing result Report.
+     *  \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 Result {
+    struct Report {
         
         /**
-         *  \brief Append a result to this one, replacing the error source annotation.
+         *  \brief Append a report to this one, replacing the error source annotation.
          *
          *  NOTE: A binding does not need to wrap this action.
          */
-        Result& operator+=(const Result& rhs) {
+        Report& operator+=(const Report& rhs) {
             error = rhs.error;
             warnings.insert(warnings.end(), rhs.warnings.begin(), rhs.warnings.end());
             return *this;

data/ext/snowcrash/src/StringUtility.h

@@ -45,15 +45,6 @@ namespace snowcrash {
         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);
@@ -85,7 +76,20 @@ namespace snowcrash {
         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.
@@ -104,6 +108,22 @@ namespace snowcrash {
         }
         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();
+    }
 }
 
 #endif

data/ext/snowcrash/src/SymbolTable.h

@@ -11,6 +11,7 @@
 
 #include <string>
 #include <map>
+#include "ByteBuffer.h"
 #include "RegexMatch.h"
 
 #ifdef DEBUG
@@ -31,13 +32,10 @@ namespace snowcrashconst {
 }
 
 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;
     
@@ -50,21 +48,23 @@ namespace snowcrash {
     
     // 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) {
+    inline bool GetSymbolReference(const mdp::ByteBuffer& 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) {
+    inline void PrintSymbolTable(const SymbolTable& symbolTable) {
 
         std::cout << "Resource Model Symbols:\n";
         for (ResourceModelSymbolTable::const_iterator it = symbolTable.resourceModels.begin();

data/ext/snowcrash/src/UriTemplateParser.cc

@@ -114,7 +114,7 @@ static ClassifiedExpression ClassifyExpression(const Expression& expression) {
     return undefinedExpression;
 }
 
-void URITemplateParser::parse(const URITemplate& uri, const SourceCharactersBlock& sourceBlock, ParsedURITemplate& result)
+void URITemplateParser::parse(const URITemplate& uri, const mdp::CharactersRangeSet& sourceBlock, ParsedURITemplate& result)
 {
     CaptureGroups groups;
     Expressions expressions;
@@ -128,17 +128,17 @@ void URITemplateParser::parse(const URITemplate& uri, const SourceCharactersBloc
         result.path = groups[4];
 
         if (HasMismatchedCurlyBrackets(result.path)) {
-            result.result.warnings.push_back(Warning("The URI template contains mismatched expression brackets", URIWarning, sourceBlock));
+            result.report.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));
+            result.report.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));
+            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);
@@ -155,21 +155,21 @@ void URITemplateParser::parse(const URITemplate& uri, const SourceCharactersBloc
                 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));
+                    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.result.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    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.result.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
+                    result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
                     hasIllegalCharacters = true;
                 }
                
@@ -177,18 +177,18 @@ void URITemplateParser::parse(const URITemplate& uri, const SourceCharactersBloc
                     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));
+                        result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
                     }
                 }
             }
             else{
-                result.result.warnings.push_back(Warning(classifiedExpression.unsupportedWarningText, URIWarning, sourceBlock));
+                result.report.warnings.push_back(Warning(classifiedExpression.unsupportedWarningText, URIWarning, sourceBlock));
             }
             currentExpression++;
         }
     }
     else{
-        result.result.error = Error("Failed to parse URI Template", URIWarning);
+        result.report.error = Error("Failed to parse URI Template", URIWarning);
     }
 
 }

data/ext/snowcrash/src/UriTemplateParser.h

@@ -6,20 +6,17 @@
 //  Copyright (c) 2013 Apiary Inc. All rights reserved.
 //
 
-#ifndef SNOWCRASH_H
-#define SNOWCRASH_H
+#ifndef SNOWCRASH_URITEMPLATEPARSER_H
+#define SNOWCRASH_URITEMPLATEPARSER_H
 
-#include <string>
 #include "Blueprint.h"
-#include "Parser.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 {
     
     /**
@@ -30,7 +27,7 @@ namespace snowcrash {
         std::string host;
         std::string path;
         
-        Result result;
+        Report report;
     };
     
     /**
@@ -69,19 +66,19 @@ namespace snowcrash {
             return false;
         }
                 
-        FORCEINLINE bool ContainsSpaces() {
+        bool ContainsSpaces() {
             return innerExpression.find(" ") != std::string::npos;
         }
 
-        FORCEINLINE bool ContainsAssignment() {
+        bool ContainsAssignment() {
             return innerExpression.find("=") != std::string::npos;
         }
 
-        FORCEINLINE bool ContainsHyphens() {
+        bool ContainsHyphens() {
             return innerExpression.find("-") != std::string::npos;
         }
 
-        FORCEINLINE bool IsInvalidExpressionName() {
+        bool IsInvalidExpressionName() {
             std::string tmpExpression = innerExpression;
             if (tmpExpression.find("..") != std::string::npos) return true;
             
@@ -94,7 +91,7 @@ namespace snowcrash {
             return !RegexMatch(tmpExpression, URI_TEMPLATE_EXPRESSION_REGEX);
         }
 
-        FORCEINLINE bool IsSupportedExpressionType() {
+        bool IsSupportedExpressionType() {
             return isSupported;
         }
     };
@@ -236,7 +233,7 @@ namespace snowcrash {
         *
         *  \param uri        A uri to be parsed.
         */
-        static void parse(const URITemplate& uri, const SourceCharactersBlock& sourceBlock, ParsedURITemplate& result);
+        static void parse(const URITemplate& uri, const mdp::CharactersRangeSet& sourceBlock, ParsedURITemplate& result);
     };
 }
 

data/ext/snowcrash/src/ValuesParser.h

@@ -0,0 +1,122 @@
+//
+//  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 */
+    typedef Collection<Value>::type Values; // TODO: Move this into core later
+
+    /** 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,
+                                                         Report& report,
+                                                         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.push_back(captureGroups[1]);
+                } 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.sourceData);
+                    report.warnings.push_back(Warning(ss.str(),
+                                                      IgnoringWarning,
+                                                      sourceMap));
+                }
+
+                return ++MarkdownNodeIterator(node);
+            }
+
+            return node;
+        }
+
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       Report& report,
+                                                       Values& out) {
+
+            return node;
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            return false;
+        }
+
+        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