redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/SectionParserData.h

@@ -25,9 +25,9 @@ namespace snowcrash {
         RequireBlueprintNameOption = (1 << 1),  /// < Treat missing blueprint name as error
         ExportSourcemapOption = (1 << 2)        /// < Export source maps AST
     };
-    
+
     typedef unsigned int BlueprintParserOptions;
-    
+
     /**
      *  \brief Section Parser Data
      *
@@ -38,22 +38,22 @@ namespace snowcrash {
                           const mdp::ByteBuffer& src,
                           const Blueprint& bp)
         : options(opts), sourceData(src), blueprint(bp) {}
-        
+
         /** Parser Options */
         BlueprintParserOptions options;
-        
+
         /** Symbol Table */
         SymbolTable symbolTable;
-        
+
         /** Symbol Table Sourcemap */
         SymbolSourceMapTable symbolSourceMapTable;
 
         /** Source Data */
         const mdp::ByteBuffer& sourceData;
-        
+
         /** AST being parsed **/
         const Blueprint& blueprint;
-        
+
         /** Sections Context */
         typedef std::vector<SectionType> SectionsStack;
         SectionsStack sectionsContext;
@@ -62,19 +62,19 @@ namespace snowcrash {
         SectionType sectionContext() const {
             return (sectionsContext.empty()) ? UndefinedSectionType : sectionsContext.back();
         }
-        
+
         /** \returns Parent Section Context */
         SectionType parentSectionContext() const {
             if (sectionsContext.empty())
                 return UndefinedSectionType;
-            
+
             size_t size = sectionsContext.size();
             if (size == 1)
                 return sectionsContext.back();
             else
                 return sectionsContext[size-2];
         }
-        
+
         /** \returns True if exporting source maps */
         bool exportSourceMap() const {
             return options & ExportSourcemapOption;

data/ext/snowcrash/src/SectionProcessor.h

@@ -14,13 +14,13 @@
 #include "Signature.h"
 
 namespace snowcrash {
-    
+
     using mdp::MarkdownNode;
     using mdp::MarkdownNodes;
     using mdp::MarkdownNodeIterator;
-    
+
     typedef Collection<SectionType>::type SectionTypes;
-    
+
     /**
      *  Layout of the section being parsed
      */
@@ -31,24 +31,64 @@ namespace snowcrash {
     };
 
     /**
-     * Compound product of parsing a node
+     *  \brief Complete compound product of parsing
+     *
+     *  This structure owns all of the product data. As such
+     *  it shouldn't be used internally unless there is a need
+     *  for storing complete parser data. See %IntermediateParseResult.
      */
     template<typename T>
     struct ParseResult {
-        ParseResult(Report& report_,
-                    T& node_,
-                    SourceMap<T>& sourceMap_)
-        : report(report_), node(node_), sourceMap(sourceMap_) {}
 
-        ParseResult(Report& report_)
-        : report(report_), node(*(new T)), sourceMap(*(new SourceMap<T>)) {}
+        ParseResult(const Report& report_ = Report())
+        : report(report_) {}
 
-        ParseResult()
-        : report(*(new Report)), node(*(new T)), sourceMap(*(new SourceMap<T>)) {}
+        Report report;           /// Parser's report
+        T node;                  /// Parsed AST node
+        SourceMap<T> sourceMap;  /// Parsed AST node source map
+    };
 
-        Report& report;           /// Parser's report
-        T& node;                  /// Parsed AST node
-        SourceMap<T>& sourceMap;  /// Parsed AST node source map
+    /**
+     *  \brief Partial product of parsing.
+     *
+     *  This structure owns the node being parsed and its source map.
+     *  Unlike %ParseResult it relies on shared parser report data making it
+     *  ideal for holding temporary results while parsing items of a collection.
+     */
+    template<typename T>
+    struct IntermediateParseResult {
+
+        explicit IntermediateParseResult(Report& report_)
+        : report(report_) {}
+
+        Report& report;
+        T node;
+        SourceMap<T> sourceMap;
+    };
+
+    /**
+     *  \brief Reference wrapper for parsing data product
+     *
+     *  Reference wrapper for %ParseResult and %IntermediateParseResult.
+     */
+    template<typename T>
+    struct ParseResultRef {
+
+        ParseResultRef(ParseResult<T>& parseResult)
+        : report(parseResult.report), node(parseResult.node), sourceMap(parseResult.sourceMap) {}
+
+        ParseResultRef(IntermediateParseResult<T>& parseResult)
+        : report(parseResult.report), node(parseResult.node), sourceMap(parseResult.sourceMap) {}
+
+        ParseResultRef(Report& report_, T& node_, SourceMap<T>& sourceMap_)
+        : report(report_), node(node_), sourceMap(sourceMap_) {}
+
+        Report& report;
+        T& node;
+        SourceMap<T>& sourceMap;
+
+    private:
+        ParseResultRef();
     };
 
     /*
@@ -56,7 +96,7 @@ namespace snowcrash {
      */
     template<typename T>
     struct SectionProcessor;
-    
+
     /**
      *  \brief  Section Processor Base
      *
@@ -79,7 +119,7 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     ParseResult<T>& out) {
+                                                     const ParseResultRef<T>& out) {
 
             return ++MarkdownNodeIterator(node);
         }
@@ -88,7 +128,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       ParseResult<T>& out) {
+                                                       const ParseResultRef<T>& out) {
 
             if (!out.node.description.empty()) {
                 TwoNewLines(out.node.description);
@@ -104,16 +144,16 @@ namespace snowcrash {
 
             return ++MarkdownNodeIterator(node);
         }
-        
+
         /** Process section-specific content Markdown node */
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
                                                    SectionParserData& pd,
-                                                   ParseResult<T>& out) {
+                                                   const ParseResultRef<T>& out) {
 
             return ++MarkdownNodeIterator(node);
         }
-        
+
         /**
          *  \brief Process nested sections Markdown node(s)
          *  \param node     Node to process
@@ -125,17 +165,17 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<T>& out) {
+                                                         const ParseResultRef<T>& out) {
 
             return node;
         }
-        
+
         /** Process unexpected Markdown node */
         static MarkdownNodeIterator processUnexpectedNode(const MarkdownNodeIterator& node,
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& lastSectionType,
-                                                          ParseResult<T>& out) {
+                                                          const ParseResultRef<T>& out) {
 
             // WARN: Ignoring unexpected node
             std::stringstream ss;
@@ -158,9 +198,9 @@ namespace snowcrash {
         /** Final validation after processing */
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             ParseResult<T>& out) {
+                             const ParseResultRef<T>& out) {
         }
-        
+
         /** \return True if the node is a section description node */
         static bool isDescriptionNode(const MarkdownNodeIterator& node,
                                       SectionType sectionType) {
@@ -197,14 +237,14 @@ namespace snowcrash {
         /** \return True if the node is unexpected in the current context */
         static bool isUnexpectedNode(const MarkdownNodeIterator& node,
                                      SectionType sectionType) {
-            
+
             SectionType keywordSectionType = SectionKeywordSignature(node);
             SectionTypes nestedTypes = SectionProcessor<T>::nestedSectionTypes();
 
             if (std::find(nestedTypes.begin(), nestedTypes.end(), keywordSectionType) != nestedTypes.end()) {
                 return true;
             }
-            
+
             return (keywordSectionType == UndefinedSectionType);
         }
 
@@ -217,13 +257,13 @@ namespace snowcrash {
         static SectionType sectionType(const MarkdownNodeIterator& node) {
             return UndefinedSectionType;
         }
-        
+
         /** \return Nested %SectionType of the node */
         static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
             return UndefinedSectionType;
         }
     };
-    
+
     /**
      *  Default Section Processor
      */

data/ext/snowcrash/src/Serialize.h

@@ -15,7 +15,7 @@
 #define AST_SERIALIZATION_VERSION "2.1"
 
 namespace snowcrash {
-    
+
     /**
      *  \brief  Escape new lines in input string.
      *  \param  input   A string to escape its new lines.
@@ -24,14 +24,14 @@ namespace snowcrash {
      *  This function replaces all occurences of "\n" with "\\n".
      */
     std::string EscapeNewlines(const std::string& input);
-    
+
     /**
      *  \brief  Escape every double quote in input string.
      *  \param  input   A string to escape its double quotes.
      *  \return A new string with double quotes escaped.
      */
     std::string EscapeDoubleQuotes(const std::string& input);
-    
+
     /**
      *  AST entities serialization keys
      */

data/ext/snowcrash/src/SerializeJSON.cc

@@ -47,22 +47,22 @@ static void indent(size_t level, std::ostream &os)
 static void serialize(const std::string& key, const std::string& value, size_t level, bool object, std::ostream &os)
 {
     indent(level, os);
-    
+
     if (object) {
         os << "{\n";
         indent(level + 1, os);
     }
-    
+
     serialize(key, os);
     os << ": ";
-    
+
     std::string normValue = EscapeDoubleQuotes(value);
 
     if (normValue.find("\n") != std::string::npos)
         serialize(EscapeNewlines(normValue), os);
     else
         serialize(normValue, os);
-    
+
     if (object) {
         os << "\n";
         indent(level, os);
@@ -97,13 +97,13 @@ static void serialize(const std::string& key, const std::string& value, size_t l
     indent(level, os);
 
     os << "{\n";
-    
+
     serialize(SerializeKey::Name, key, level + 1, false, os);
     os << NewLineItemBlock;
-    
+
     serialize(SerializeKey::Value, value, level + 1, false, os);
     os << "\n";
-    
+
     indent(level, os);
     os << "}";
 }
@@ -236,9 +236,9 @@ static void serialize(const MetadataCollection& metadata, std::ostream &os)
     indent(1, os);
     serialize(SerializeKey::Metadata, os);
     os << ": ";
-    
+
     serializeKeyValueCollection(metadata, 1, os);
-    
+
     os << NewLineItemBlock;
 }
 
@@ -269,43 +269,43 @@ static void serialize(const Parameters& parameters, size_t level, std::ostream &
     indent(level, os);
     serialize(SerializeKey::Parameters, os);
     os << ": [";
-    
+
     if (!parameters.empty()) {
         os << "\n";
         size_t i = 0;
 
         for (Collection<Parameter>::const_iterator it = parameters.begin(); it != parameters.end(); ++i, ++it) {
-            
+
             if (i > 0 && i < parameters.size())
                 os << NewLineItemBlock;
 
             indent(level + 1, os);
             os << "{\n";
-            
+
             // Name
             serialize(SerializeKey::Name, it->name, level + 2, false, os);
             os << NewLineItemBlock;
-            
+
             // Description
             serialize(SerializeKey::Description, it->description, level + 2, false, os);
             os << NewLineItemBlock;
-            
+
             // Type
             serialize(SerializeKey::Type, it->type, level + 2, false, os);
             os << NewLineItemBlock;
-            
+
             // Requried
             serialize(SerializeKey::Required, (it->use != OptionalParameterUse), level + 2, os);
             os << NewLineItemBlock;
-            
+
             // Default
             serialize(SerializeKey::Default, it->defaultValue, level + 2, false, os);
             os << NewLineItemBlock;
-            
+
             // Example
             serialize(SerializeKey::Example, it->exampleValue, level + 2, false, os);
             os << NewLineItemBlock;
-            
+
             // Values
             indent(level + 2, os);
             serialize(SerializeKey::Values, os);
@@ -318,30 +318,30 @@ static void serialize(const Parameters& parameters, size_t level, std::ostream &
                 for (Collection<Value>::const_iterator val_it = it->values.begin();
                      val_it != it->values.end();
                      ++j, ++val_it) {
-                    
+
                     if (j > 0 && j < it->values.size())
                         os << NewLineItemBlock;
-                    
+
                     serialize(SerializeKey::Value, *val_it, level + 3, true, os);
                 }
-                
+
                 os << "\n";
                 indent(level + 2, os);
             }
-            
+
             // Close Values
             os << "]";
-            
+
             // Close Key / name object
             os << "\n";
             indent(level + 1, os);
             os << "}";
         }
-        
+
         os << std::endl;
         indent(level, os);
     }
-    
+
     os << "]";
 }
 
@@ -445,7 +445,7 @@ static void serialize(const Headers& headers, size_t level, std::ostream &os)
     indent(level, os);
     serialize(SerializeKey::Headers, os);
     os << ": ";
-    
+
     serializeKeyValueCollection(headers, level, os);
 }
 
@@ -464,6 +464,46 @@ static void serialize(const Collection<SourceMap<Header> >::type& headers, size_
     serializeSourceMapCollection(headers, level, os);
 }
 
+/**
+ * \brief Serialize a reference into output stream.
+ * \param reference A reference to serialize.
+ * \param os An output stream to serialize into.
+ */
+static void serialize(const Reference& reference, size_t level, std::ostream &os)
+{
+
+    if (reference.id.empty()) {
+        return;
+    }
+
+    indent(level, os);
+    os << "\"" << SerializeKey::Reference << "\": {\n";
+
+    serialize(SerializeKey::Id, reference.id, level + 1, false, os);
+    os << "\n";
+
+    indent(level, os);
+    os << "}";
+
+    os << NewLineItemBlock;
+}
+
+/**
+ * \brief Serialize a reference source map into output stream.
+ * \param reference A reference source map to serialize.
+ * \param os An output stream to serialize into.
+ */
+static void serialize(const SourceMap<Reference>& reference, size_t level, std::ostream &os)
+{
+
+    if (reference.sourceMap.empty()) {
+        return;
+    }
+
+    serialize(SerializeKey::Reference, reference, level, false, os);
+    os << NewLineItemBlock;
+}
+
 /**
  * \brief Serialize a payload into output stream.
  * \param payload   A payload to serialize.
@@ -477,30 +517,21 @@ static void serialize(const Payload& payload, size_t level, std::ostream &os)
     serialize(SerializeKey::Name, payload.name, level + 1, false, os);
     os << NewLineItemBlock;
 
-    // Symbol Reference
-    if (!payload.symbol.empty()) {
-        indent(level + 1, os);
-        os << "\"" << SerializeKey::Reference << "\": {\n";
-
-        serialize(SerializeKey::Id, payload.symbol, level + 2, false, os);
-
-        os << "\n";
-        indent(level + 1, os);
-        os << "}" << NewLineItemBlock;
-    }
+    // Reference
+    serialize(payload.reference, level + 1, os);
 
     // Description
     serialize(SerializeKey::Description, payload.description, level + 1, false, os);
     os << NewLineItemBlock;
-    
+
     // Headers
     serialize(payload.headers, level + 1, os);
     os << NewLineItemBlock;
-    
+
     // Body
     serialize(SerializeKey::Body, payload.body, level + 1, false, os);
     os << NewLineItemBlock;
-    
+
     // Schema
     serialize(SerializeKey::Schema, payload.schema, level + 1, false, os);
 
@@ -523,10 +554,7 @@ static void serialize(const SourceMap<Payload>& payload, size_t level, std::ostr
     os << NewLineItemBlock;
 
     // Symbol Reference
-    if (!payload.symbol.sourceMap.empty()) {
-        serialize(SerializeKey::Reference, payload.symbol, level + 1, false, os);
-        os << NewLineItemBlock;
-    }
+    serialize(payload.reference, level + 1, os);
 
     // Description
     serialize(SerializeKey::Description, payload.description, level + 1, false, os);
@@ -557,21 +585,21 @@ static void serialize(const TransactionExample& example, std::ostream &os)
 {
     indent(8, os);
     os << "{\n";
-    
+
     // Name
     serialize(SerializeKey::Name, example.name, 9, false, os);
     os << NewLineItemBlock;
-    
+
     // Description
     serialize(SerializeKey::Description, example.description, 9, false, os);
     os << NewLineItemBlock;
-    
+
     // Requests
     indent(9, os);
     serialize(SerializeKey::Requests, os);
     os << ": ";
     os << "[";
-    
+
     if (!example.requests.empty()) {
         os << "\n";
         size_t i = 0;
@@ -579,26 +607,26 @@ static void serialize(const TransactionExample& example, std::ostream &os)
         for (Collection<Request>::const_iterator it = example.requests.begin();
              it != example.requests.end();
              ++i, ++it) {
-            
+
             if (i > 0 && i < example.requests.size())
                 os << NewLineItemBlock;
-            
+
             indent(10, os);
             serialize(*it, 10, os);
         }
-        
+
         os << "\n";
         indent(9, os);
     }
     os << "]";
     os << NewLineItemBlock;
-    
+
     // Responses
     indent(9, os);
     serialize(SerializeKey::Responses, os);
     os << ": ";
     os << "[";
-    
+
     if (!example.responses.empty()) {
         os << "\n";
         size_t i = 0;
@@ -606,19 +634,19 @@ static void serialize(const TransactionExample& example, std::ostream &os)
         for (Collection<Response>::const_iterator it = example.responses.begin();
              it != example.responses.end();
              ++i, ++it) {
-            
+
             if (i > 0 && i < example.responses.size())
                 os << NewLineItemBlock;
-            
+
             indent(10, os);
             serialize(*it, 10, os);
         }
-        
+
         os << "\n";
         indent(9, os);
     }
     os << "]";
-    
+
     // Close the transaction
     os << "\n";
     indent(8, os);
@@ -711,29 +739,29 @@ static void serialize(const Action& action, std::ostream &os)
 {
     indent(6, os);
     os << "{\n";
-    
+
     // Name
     serialize(SerializeKey::Name, action.name, 7, false, os);
     os << NewLineItemBlock;
-    
+
     // Description
     serialize(SerializeKey::Description, action.description, 7, false, os);
     os << NewLineItemBlock;
-    
+
     // HTTP Method
     serialize(SerializeKey::Method, action.method, 7, false, os);
     os << NewLineItemBlock;
-    
+
     // Parameters
     serialize(action.parameters, 7, os);
     os << NewLineItemBlock;
-    
+
     // Transactions
     indent(7, os);
     serialize(SerializeKey::Examples, os);
     os << ": ";
     os << "[";
-    
+
     if (!action.examples.empty()) {
         os << "\n";
         size_t i = 0;
@@ -741,19 +769,19 @@ static void serialize(const Action& action, std::ostream &os)
         for (Collection<TransactionExample>::const_iterator it = action.examples.begin();
              it != action.examples.end();
              ++i, ++it) {
-            
+
             if (i > 0 && i < action.examples.size())
                 os << NewLineItemBlock;
-            
+
             serialize(*it, os);
         }
-        
+
         os << "\n";
         indent(7, os);
     }
-    
+
     os << "]";
-    
+
     // Close the action
     os << "\n";
     indent(6, os);
@@ -831,15 +859,15 @@ static void serialize(const Resource& resource, std::ostream &os)
     // Name
     serialize(SerializeKey::Name, resource.name, 5, false, os);
     os << NewLineItemBlock;
-    
+
     // Description
     serialize(SerializeKey::Description, resource.description, 5, false, os);
     os << NewLineItemBlock;
-    
+
     // URI template
     serialize(SerializeKey::URITemplate, resource.uriTemplate, 5, false, os);
     os << NewLineItemBlock;
-    
+
     // Model
     indent(5, os);
     serialize(SerializeKey::Model, os);
@@ -848,15 +876,15 @@ static void serialize(const Resource& resource, std::ostream &os)
     }
     else {
         os << ": ";
-        
+
         serialize(resource.model, 5, os);
     }
     os << NewLineItemBlock;
-    
+
     // Parameters
     serialize(resource.parameters, 5, os);
     os << NewLineItemBlock;
-    
+
     // Actions
     indent(5, os);
     serialize(SerializeKey::Actions, os);
@@ -870,23 +898,23 @@ static void serialize(const Resource& resource, std::ostream &os)
         for (Collection<Action>::const_iterator it = resource.actions.begin();
              it != resource.actions.end();
              ++i, ++it) {
-            
+
             if (i > 0 && i < resource.actions.size())
                 os << NewLineItemBlock;
-            
+
             serialize(*it, os);
         }
-        
+
         os << "\n";
         indent(5, os);
     }
 
     os << "]";
-    
+
     // Close the resource
     os << "\n";
     indent(4, os);
-    os << "}";    
+    os << "}";
 }
 
 /**
@@ -969,21 +997,21 @@ static void serialize(const ResourceGroup& resourceGroup, std::ostream &os)
 {
     indent(2, os);
     os << "{\n";
-    
+
     // Name
     serialize(SerializeKey::Name, resourceGroup.name, 3, false, os);
     os << NewLineItemBlock;
-    
+
     // Description
     serialize(SerializeKey::Description, resourceGroup.description, 3, false, os);
     os << NewLineItemBlock;
-    
+
     // Resources
     indent(3, os);
     serialize(SerializeKey::Resources, os);
     os << ": ";
     os << "[";
-    
+
     if (!resourceGroup.resources.empty()) {
         os << "\n";
         size_t i = 0;
@@ -991,21 +1019,21 @@ static void serialize(const ResourceGroup& resourceGroup, std::ostream &os)
         for (Collection<Resource>::const_iterator it = resourceGroup.resources.begin();
              it != resourceGroup.resources.end();
              ++i, ++it) {
-            
+
             if (i > 0 && i < resourceGroup.resources.size())
                 os << NewLineItemBlock;
-            
+
             serialize(*it, os);
         }
-        
+
         if (!resourceGroup.resources.empty()) {
             os << "\n";
             indent(3, os);
         }
     }
-    
+
     os << "]";
-    
+
     // Close the group
     os << "\n";
     indent(2, os);
@@ -1075,23 +1103,23 @@ static void serialize(const ResourceGroups& resourceGroups, std::ostream &os)
     serialize(SerializeKey::ResourceGroups, os);
     os << ": ";
     os << "[";
-    
+
     if (!resourceGroups.empty()) {
         os << "\n";
         size_t i = 0;
 
         for (Collection<ResourceGroup>::const_iterator it = resourceGroups.begin(); it != resourceGroups.end(); ++i, ++it) {
-            
+
             if (i > 0 && i < resourceGroups.size())
                 os << NewLineItemBlock;
-            
+
             serialize(*it, os);
         }
-        
+
         os << "\n";
         indent(1, os);
     }
-    
+
     os << "]";
 }
 
@@ -1134,11 +1162,11 @@ static void serialize(const Collection<SourceMap<ResourceGroup> >::type& resourc
 static void serialize(const Blueprint& blueprint, std::ostream &os)
 {
     os << "{\n";
-    
+
     // AST Version
     serialize(SerializeKey::ASTVersion, AST_SERIALIZATION_VERSION, 1, false, os);
     os << NewLineItemBlock;
-    
+
     // Metadata
     serialize(blueprint.metadata, os);
 
@@ -1152,7 +1180,7 @@ static void serialize(const Blueprint& blueprint, std::ostream &os)
 
     // Resource Groups
     serialize(blueprint.resourceGroups, os);
-    
+
     os << "\n}\n";
 }