redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/CBlueprintSourcemap.cc

@@ -272,16 +272,6 @@ SC_API const sc_source_map_t* sc_sm_payload_name(const sc_sm_payload_t* handle)
     return AS_CTYPE(sc_source_map_t, &p->name.sourceMap);
 }
 
-/** TODO: Need to change this to use the "Reference" data structure */
-SC_API const sc_source_map_t* sc_sm_payload_symbol(const sc_sm_payload_t* handle)
-{
-    const snowcrash::SourceMap<snowcrash::Payload>* p = AS_CTYPE(snowcrash::SourceMap<snowcrash::Payload>, handle);
-    if (!p)
-        return NULL;
-
-    return AS_CTYPE(sc_source_map_t, &p->symbol.sourceMap);
-}
-
 SC_API const sc_source_map_t* sc_sm_payload_description(const sc_sm_payload_t* handle)
 {
     const snowcrash::SourceMap<snowcrash::Payload>* p = AS_CTYPE(snowcrash::SourceMap<snowcrash::Payload>, handle);
@@ -311,6 +301,26 @@ SC_API const sc_source_map_t* sc_sm_payload_schema(const sc_sm_payload_t* handle
 
 /*----------------------------------------------------------------------*/
 
+SC_API const sc_sm_reference_t* sc_sm_reference_handle(const sc_sm_payload_t* handle)
+{
+    const snowcrash::SourceMap<snowcrash::Payload>* p = AS_CTYPE(snowcrash::SourceMap<snowcrash::Payload>, handle);
+    if(!p)
+        return NULL;
+
+    return AS_CTYPE(sc_sm_reference_t, &p->reference);
+}
+
+SC_API const sc_source_map_t* sc_sm_reference(const sc_sm_reference_t* handle)
+{
+    const snowcrash::SourceMap<snowcrash::Reference>* p = AS_CTYPE(snowcrash::SourceMap<snowcrash::Reference>, handle);
+    if (!p)
+        return NULL;
+
+    return AS_CTYPE(sc_source_map_t, &p->sourceMap);
+}
+
+/*----------------------------------------------------------------------*/
+
 SC_API const sc_sm_parameter_collection_t* sc_sm_parameter_collection_handle_payload(const sc_sm_payload_t* handle)
 {
     const snowcrash::SourceMap<snowcrash::Payload>* p = AS_CTYPE(snowcrash::SourceMap<snowcrash::Payload>, handle);

data/ext/snowcrash/src/CBlueprintSourcemap.h

@@ -53,6 +53,10 @@ extern "C" {
     struct sc_sm_resource_model_s;
     typedef struct sc_sm_resource_model_s sc_sm_resource_model_t;
 
+    /** Class Reference source map wrapper */
+    struct sc_sm_reference_s;
+    typedef struct sc_sm_reference_s sc_sm_reference_t;
+
     /** Array Payload Collection source map wrapper */
     struct sc_sm_payload_collection_s;
     typedef struct sc_sm_payload_collection_s sc_sm_payload_collection_t;
@@ -205,9 +209,6 @@ extern "C" {
     /** \returns Payload name source map */
     SC_API const sc_source_map_t* sc_sm_payload_name(const sc_sm_payload_t* handle);
 
-    /** \returns Payload symbol name source map */
-    SC_API const sc_source_map_t* sc_sm_payload_symbol(const sc_sm_payload_t* handle);
-
     /** \returns Payload description source map */
     SC_API const sc_source_map_t* sc_sm_payload_description(const sc_sm_payload_t* handle);
 
@@ -219,6 +220,14 @@ extern "C" {
 
     /*----------------------------------------------------------------------*/
 
+    /** \returns Reference source map handle */
+    SC_API const sc_sm_reference_t* sc_sm_reference_handle(const sc_sm_payload_t* handle);
+
+    /** \returns Reference identifier source map */
+    SC_API const sc_source_map_t* sc_sm_reference(const sc_sm_reference_t* handle);
+
+    /*----------------------------------------------------------------------*/
+
     /** \returns Parameter Collection source map array handle from Payload source map */
     SC_API const sc_sm_parameter_collection_t* sc_sm_parameter_collection_handle_payload(const sc_sm_payload_t* handle);
 

data/ext/snowcrash/src/CodeBlockUtility.h

@@ -14,9 +14,9 @@
 #include "StringUtility.h"
 
 namespace snowcrash {
-    
+
     struct CodeBlockUtility {
-        
+
         /**
          *  \brief Expected indentation level of a code block.
          *
@@ -30,21 +30,21 @@ namespace snowcrash {
                 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
@@ -57,14 +57,14 @@ namespace snowcrash {
                                        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);
 
@@ -79,25 +79,25 @@ namespace snowcrash {
 
             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.sourceData);
             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";
 
@@ -114,13 +114,13 @@ namespace snowcrash {
             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.sourceData);
             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.
@@ -128,7 +128,7 @@ namespace snowcrash {
         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);
@@ -138,11 +138,11 @@ namespace snowcrash {
             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) {
@@ -172,7 +172,7 @@ namespace snowcrash {
                                                   IndentationWarning,
                                                   sourceMap));
             }
-            
+
             return false;
         }
 
@@ -184,15 +184,15 @@ namespace snowcrash {
          */
         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());
         }
 
@@ -218,14 +218,14 @@ namespace snowcrash {
 
             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;
@@ -250,7 +250,7 @@ namespace snowcrash {
                                            Report& report) {
 
             mdp::ByteBuffer source = node->text;
-            SymbolName symbol;
+            Identifier symbol;
 
             TrimString(source);
 

data/ext/snowcrash/src/HTTP.cc

@@ -15,6 +15,9 @@ 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";
 

data/ext/snowcrash/src/HTTP.h

@@ -13,7 +13,7 @@
 #include "Blueprint.h"
 
 /**
- *  \brief HTTP Methods 
+ *  \brief HTTP Methods
  *
  *  Technical note: Using preprocessor macro instead of strict
  *  defined type due to C++98 string concatenation limitations.
@@ -21,7 +21,7 @@
  */
 #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).
@@ -29,7 +29,7 @@
 #define URI_TEMPLATE "(/.*)"
 
 namespace snowcrash {
-    
+
     /**
      *  Selected HTTP Header names.
      */
@@ -38,6 +38,9 @@ namespace snowcrash {
         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;
     };
 
     /**
@@ -57,9 +60,9 @@ namespace snowcrash {
      *  Traits of a HTTP response.
      */
     struct HTTPResponseTraits {
-        
+
         bool allowBody; /// < Response body is allowed.
-        
+
         HTTPResponseTraits() : allowBody(true) {}
     };
 
@@ -86,7 +89,7 @@ namespace snowcrash {
         HTTPStatusCode code;
         StatusCodeTraits() : code(0) {}
     };
-    
+
     /**
      *  \brief  Retrieve response traits for given HTTP method.
      *  \param  method  HTTP method to retrieve traits for.

data/ext/snowcrash/src/HeadersParser.h

@@ -22,18 +22,18 @@ namespace snowcrash {
 
     /** Header Iterator in its containment group */
     typedef Collection<Header>::const_iterator HeaderIterator;
-    
+
     /**
      *  Headers Section Processor
      */
     template<>
     struct SectionProcessor<Headers> : public SectionProcessorBase<Headers> {
-        
+
         static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<Headers>& out) {
+                                                     const ParseResultRef<Headers>& out) {
 
             mdp::ByteBuffer content;
             CodeBlockUtility::signatureContentAsCodeBlock(node, pd, out.report, content);
@@ -42,11 +42,11 @@ namespace snowcrash {
 
             return ++MarkdownNodeIterator(node);
         }
-        
+
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       ParseResult<Headers>& out) {
+                                                       const ParseResultRef<Headers>& out) {
 
             return node;
         }
@@ -54,7 +54,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
                                                    SectionParserData& pd,
-                                                   ParseResult<Headers>& out) {
+                                                   const ParseResultRef<Headers>& out) {
 
             mdp::ByteBuffer content;
             CodeBlockUtility::contentAsCodeBlock(node, pd, out.report, content);
@@ -63,18 +63,18 @@ namespace snowcrash {
 
             return ++MarkdownNodeIterator(node);
         }
-        
+
         static bool isDescriptionNode(const MarkdownNodeIterator& node,
                                       SectionType sectionType) {
             return false;
         }
-        
+
         static bool isContentNode(const MarkdownNodeIterator& node,
                                   SectionType sectionType) {
 
             return (SectionKeywordSignature(node) == UndefinedSectionType);
         }
-        
+
         static SectionType sectionType(const MarkdownNodeIterator& node) {
 
             if (node->type == mdp::ListItemMarkdownNodeType
@@ -83,7 +83,7 @@ namespace snowcrash {
                 mdp::ByteBuffer subject = node->children().front().text;
                 mdp::ByteBuffer signature;
                 mdp::ByteBuffer remainingContent;
-                
+
                 signature = GetFirstLine(subject, remainingContent);
                 TrimString(signature);
 
@@ -96,7 +96,7 @@ namespace snowcrash {
 
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<Headers>& out) {
+                             const ParseResultRef<Headers>& out) {
 
             if (out.node.empty()) {
 
@@ -112,7 +112,7 @@ namespace snowcrash {
         static void headersFromContent(const MarkdownNodeIterator& node,
                                        const mdp::ByteBuffer& content,
                                        SectionParserData& pd,
-                                       ParseResult<Headers>& out) {
+                                       const ParseResultRef<Headers>& out) {
 
             std::vector<std::string> lines = Split(content, '\n');
 
@@ -127,7 +127,7 @@ namespace snowcrash {
                 Header header;
 
                 if (CodeBlockUtility::keyValueFromLine(*line, header)) {
-                    if (findHeader(out.node, header) != out.node.end()) {
+                    if (findHeader(out.node, header) != out.node.end() && !isAllowedMultipleDefinition(header)) {
                         // WARN: duplicate header on this level
                         std::stringstream ss;
 
@@ -228,7 +228,27 @@ namespace snowcrash {
 
             return std::find_if(headers.begin(),
                                 headers.end(),
-                                std::bind2nd(MatchFirsts<Header>(), header));
+                                std::bind2nd(MatchFirsts<Header, IEqual<typename Header::first_type> >(), header));
+        }
+
+        typedef std::vector<std::string> HeadersKeyCollection;
+        /** Get collection of allowed keywords - workarround due to C++98 restriction - static initialization of vector */
+        static const HeadersKeyCollection& getAllowedMultipleDefinitions() {
+            static std::string keys[] = {
+                HTTPHeaderName::SetCookie,
+                HTTPHeaderName::Link,
+            };
+
+            static const HeadersKeyCollection allowedMultipleDefinitions(keys, keys + (sizeof(keys)/sizeof(keys[0])));
+            return allowedMultipleDefinitions;
+        }
+
+        /** Check if Header name has allowed multiple definitions */
+        static bool isAllowedMultipleDefinition(const Header& header) {
+              const HeadersKeyCollection& keys = getAllowedMultipleDefinitions();
+              return std::find_if(keys.begin(),
+                                  keys.end(),
+                                  std::bind1st(MatchFirstWith<Header, std::string, IEqual<std::string> >(), header)) != keys.end();
         }
     };