redsnow 0.2.0 → 0.2.1

data/ext/snowcrash/src/SectionParser.h

@@ -34,8 +34,7 @@ namespace snowcrash {
         static MarkdownNodeIterator parse(const MarkdownNodeIterator& node,
                                           const MarkdownNodes& siblings,
                                           SectionParserData& pd,
-                                          Report& report,
-                                          T& out) {
+                                          ParseResult<T>& out) {
             
             SectionLayout layout = DefaultSectionLayout;
             MarkdownNodeIterator cur = Adapter::startingNode(node);
@@ -43,21 +42,21 @@ namespace snowcrash {
             
             // Signature node
             MarkdownNodeIterator lastCur = cur;
-            cur = SectionProcessor<T>::processSignature(cur, collection, pd, layout, report, out);
+            cur = SectionProcessor<T>::processSignature(cur, collection, pd, layout, out);
 
             // Exclusive Nested Sections Layout
             if (layout == ExclusiveNestedSectionLayout) {
 
-                cur = parseNestedSections(cur, collection, pd, report, out);
+                cur = parseNestedSections(cur, collection, pd, out);
                 
-                SectionProcessor<T>::finalize(node, pd, report, out);
+                SectionProcessor<T>::finalize(node, pd, out);
                 
                 return Adapter::nextStartingNode(node, siblings, cur);
             }
             
             // Parser redirect layout
             if (layout == RedirectSectionLayout) {
-                SectionProcessor<T>::finalize(node, pd, report, out);
+                SectionProcessor<T>::finalize(node, pd, out);
                 
                 return Adapter::nextStartingNode(node, siblings, cur);
             }
@@ -71,7 +70,8 @@ namespace snowcrash {
                   SectionProcessor<T>::isDescriptionNode(cur, pd.sectionContext())) {
                 
                 lastCur = cur;
-                cur = SectionProcessor<T>::processDescription(cur, collection, pd, report, out);
+                cur = SectionProcessor<T>::processDescription(cur, collection, pd, out);
+
                 if (lastCur == cur)
                     return Adapter::nextStartingNode(node, siblings, cur);
             }
@@ -81,15 +81,16 @@ namespace snowcrash {
                   SectionProcessor<T>::isContentNode(cur, pd.sectionContext())) {
                 
                 lastCur = cur;
-                cur = SectionProcessor<T>::processContent(cur, collection, pd, report, out);
+                cur = SectionProcessor<T>::processContent(cur, collection, pd, out);
+
                 if (lastCur == cur)
                     return Adapter::nextStartingNode(node, siblings, cur);
             }
             
             // Nested Sections
-            cur = parseNestedSections(cur, collection, pd, report, out);
+            cur = parseNestedSections(cur, collection, pd, out);
 
-            SectionProcessor<T>::finalize(node, pd, report, out);
+            SectionProcessor<T>::finalize(node, pd, out);
 
             return Adapter::nextStartingNode(node, siblings, cur);
         }
@@ -99,8 +100,7 @@ namespace snowcrash {
         static MarkdownNodeIterator parseNestedSections(const MarkdownNodeIterator& node,
                                                         const MarkdownNodes& collection,
                                                         SectionParserData& pd,
-                                                        Report& report,
-                                                        T& out) {
+                                                        ParseResult<T>& out) {
 
             MarkdownNodeIterator cur = node;
             MarkdownNodeIterator lastCur = cur;
@@ -116,11 +116,12 @@ namespace snowcrash {
                 pd.sectionsContext.push_back(nestedType);
                 
                 if (nestedType != UndefinedSectionType) {
-                    cur = SectionProcessor<T>::processNestedSection(cur, collection, pd, report, out);
+                    cur = SectionProcessor<T>::processNestedSection(cur, collection, pd, out);
                 }
                 else if (Adapter::nextSkipsUnexpected ||
                          SectionProcessor<T>::isUnexpectedNode(cur, pd.sectionContext())) {
-                    cur = SectionProcessor<T>::processUnexpectedNode(cur, collection, pd, lastSectionType, report, out);
+
+                    cur = SectionProcessor<T>::processUnexpectedNode(cur, collection, pd, lastSectionType, out);
                 }
                 
                 if (cur != collection.end() &&

data/ext/snowcrash/src/SectionParserData.h

@@ -9,7 +9,7 @@
 #ifndef SNOWCRASH_SECTIONPARSERDATA_H
 #define SNOWCRASH_SECTIONPARSERDATA_H
 
-#include "Blueprint.h"
+#include "BlueprintSourcemap.h"
 #include "Section.h"
 #include "SymbolTable.h"
 
@@ -22,7 +22,8 @@ namespace snowcrash {
      */
     enum BlueprintParserOption {
         RenderDescriptionsOption = (1 << 0),    /// < Render Markdown in description.
-        RequireBlueprintNameOption = (1 << 1)   /// < Treat missing blueprint name as error
+        RequireBlueprintNameOption = (1 << 1),  /// < Treat missing blueprint name as error
+        ExportSourcemapOption = (1 << 2)        /// < Export source maps AST
     };
     
     typedef unsigned int BlueprintParserOptions;
@@ -44,6 +45,9 @@ namespace snowcrash {
         /** Symbol Table */
         SymbolTable symbolTable;
         
+        /** Symbol Table Sourcemap */
+        SymbolSourceMapTable symbolSourceMapTable;
+
         /** Source Data */
         const mdp::ByteBuffer& sourceData;
         
@@ -71,6 +75,11 @@ namespace snowcrash {
                 return sectionsContext[size-2];
         }
         
+        /** \returns True if exporting source maps */
+        bool exportSourceMap() const {
+            return options & ExportSourcemapOption;
+        }
+
     private:
         SectionParserData();
         SectionParserData(const SectionParserData&);

data/ext/snowcrash/src/SectionProcessor.h

@@ -30,6 +30,27 @@ namespace snowcrash {
         RedirectSectionLayout          /// Section should be parsed by another parser as whole
     };
 
+    /**
+     * Compound product of parsing a node
+     */
+    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()
+        : 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
+    };
+
     /*
      * Forward Declarations
      */
@@ -58,8 +79,8 @@ namespace snowcrash {
                                                      const MarkdownNodes& siblings,
                                                      SectionParserData& pd,
                                                      SectionLayout& layout,
-                                                     Report& report,
-                                                     T& out) {
+                                                     ParseResult<T>& out) {
+
             return ++MarkdownNodeIterator(node);
         }
 
@@ -67,14 +88,19 @@ namespace snowcrash {
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       Report& report,
-                                                       T& out) {
+                                                       ParseResult<T>& out) {
 
-            if (!out.description.empty()) {
-                TwoNewLines(out.description);
+            if (!out.node.description.empty()) {
+                TwoNewLines(out.node.description);
             }
 
-            out.description += mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+            mdp::ByteBuffer content = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+
+            if (pd.exportSourceMap() && !content.empty()) {
+                out.sourceMap.description.sourceMap.append(node->sourceMap);
+            }
+
+            out.node.description += content;
 
             return ++MarkdownNodeIterator(node);
         }
@@ -83,8 +109,8 @@ namespace snowcrash {
         static MarkdownNodeIterator processContent(const MarkdownNodeIterator& node,
                                                    const MarkdownNodes& siblings,
                                                    SectionParserData& pd,
-                                                   Report& report,
-                                                   T& out) {
+                                                   ParseResult<T>& out) {
+
             return ++MarkdownNodeIterator(node);
         }
         
@@ -99,8 +125,8 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         Report& report,
-                                                         T& out) {
+                                                         ParseResult<T>& out) {
+
             return node;
         }
         
@@ -109,8 +135,7 @@ namespace snowcrash {
                                                           const MarkdownNodes& siblings,
                                                           SectionParserData& pd,
                                                           SectionType& lastSectionType,
-                                                          Report& report,
-                                                          T& out) {
+                                                          ParseResult<T>& out) {
 
             // WARN: Ignoring unexpected node
             std::stringstream ss;
@@ -123,9 +148,9 @@ namespace snowcrash {
                 ss << "ignoring unrecognized block";
             }
 
-            report.warnings.push_back(Warning(ss.str(),
-                                              IgnoringWarning,
-                                              sourceMap));
+            out.report.warnings.push_back(Warning(ss.str(),
+                                                  IgnoringWarning,
+                                                  sourceMap));
 
             return ++MarkdownNodeIterator(node);
         }
@@ -133,8 +158,7 @@ namespace snowcrash {
         /** Final validation after processing */
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
-                             Report& report,
-                             T& out) {
+                             ParseResult<T>& out) {
         }
         
         /** \return True if the node is a section description node */

data/ext/snowcrash/src/Serialize.cc

@@ -17,6 +17,8 @@ using namespace snowcrash;
 
 const std::string SerializeKey::ASTVersion = "_version";
 const std::string SerializeKey::Metadata = "metadata";
+const std::string SerializeKey::Reference = "reference";
+const std::string SerializeKey::Id = "id";
 const std::string SerializeKey::Name = "name";
 const std::string SerializeKey::Description = "description";
 const std::string SerializeKey::ResourceGroups = "resourceGroups";

data/ext/snowcrash/src/Serialize.h

@@ -12,7 +12,7 @@
 #include <string>
 
 /** Version of API Blueprint AST serialization */
-#define AST_SERIALIZATION_VERSION "2.0"
+#define AST_SERIALIZATION_VERSION "2.1"
 
 namespace snowcrash {
     
@@ -38,6 +38,8 @@ namespace snowcrash {
     struct SerializeKey {
         static const std::string ASTVersion;
         static const std::string Metadata;
+        static const std::string Reference;
+        static const std::string Id;
         static const std::string Name;
         static const std::string Description;
         static const std::string ResourceGroups;

data/ext/snowcrash/src/SerializeJSON.cc

@@ -57,6 +57,7 @@ static void serialize(const std::string& key, const std::string& value, size_t l
     os << ": ";
     
     std::string normValue = EscapeDoubleQuotes(value);
+
     if (normValue.find("\n") != std::string::npos)
         serialize(EscapeNewlines(normValue), os);
     else
@@ -107,6 +108,95 @@ static void serialize(const std::string& key, const std::string& value, size_t l
     os << "}";
 }
 
+/**
+ * \brief Serialize source map without key into output stream
+ * \param set      Source map
+ * \param level    Indentation level
+ * \param os       An output stream to serialize into
+ */
+static void serialize(const SourceMapBase& set, size_t level, std::ostream &os)
+{
+    os << "[";
+
+    if (!set.sourceMap.empty()) {
+        size_t i = 0;
+        os << "\n";
+
+        for (mdp::RangeSet<mdp::BytesRange>::const_iterator it = set.sourceMap.begin(); it != set.sourceMap.end(); ++i, ++it) {
+
+            if (i > 0 && i < set.sourceMap.size())
+                os << NewLineItemBlock;
+
+            indent(level + 1, os);
+            os << "[" << it->location << ", " << it->length << "]";
+        }
+
+        os << std::endl;
+        indent(level, os);
+    }
+
+    os << "]";
+}
+
+/**
+ * \brief Serialize a key and source map value into output stream.
+ * \param key      Key to serialize
+ * \param value    Source Map to serialize
+ * \param level    Indentation level
+ * \param object   Flag to indicate whether the pair should be serialized as an object
+ * \param os       An output stream to serialize into
+ */
+static void serialize(const std::string& key, const SourceMapBase& value, size_t level, bool object, std::ostream &os)
+{
+    indent(level, os);
+
+    if (object) {
+        os << "{\n";
+        indent(level + 1, os);
+    }
+
+    serialize(key, os);
+    os << ": ";
+
+    serialize(value, level, os);
+
+    if (object) {
+        os << "\n";
+        indent(level, os);
+        os << "}";
+    }
+}
+
+/**
+ * \brief Serialize an array of source maps.
+ * \param collection    Collection to serialize
+ * \param level         Level of indentation
+ * \param os            An output stream to serialize into
+ */
+static void serializeSourceMapCollection(const Collection<SourceMap<KeyValuePair> >::type& collection, size_t level, std::ostream &os)
+{
+    os << "[";
+
+    if (!collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<KeyValuePair> >::const_iterator it = collection.begin(); it != collection.end(); ++i, ++it) {
+
+            if (i > 0 && i < collection.size())
+                os << NewLineItemBlock;
+
+            indent(level + 1, os);
+            serialize(*it, level + 1, os);
+        }
+
+        os << "\n";
+        indent(level, os);
+    }
+
+    os << "]";
+}
+
 /**
  * \brief Serialize an array of key value pairs.
  * \param collection    Collection to serialize
@@ -116,31 +206,32 @@ static void serialize(const std::string& key, const std::string& value, size_t l
 static void serializeKeyValueCollection(const Collection<KeyValuePair>::type& collection, size_t level, std::ostream &os)
 {
     os << "[";
-    
+
     if (!collection.empty()) {
         os << "\n";
         size_t i = 0;
+
         for (Collection<KeyValuePair>::const_iterator it = collection.begin(); it != collection.end(); ++i, ++it) {
-            
+
             if (i > 0 && i < collection.size())
                 os << NewLineItemBlock;
-            
-            
+
             serialize(it->first, it->second, level + 1, os);
         }
-        
+
         os << "\n";
         indent(level, os);
     }
 
     os << "]";
 }
+
 /**
  * \brief Serialize Metadata into output stream.
  * \param metadata  Metadata to serialize
  * \param os        An output stream to serialize into
  */
-static void serialize(const Collection<Metadata>::type& metadata, std::ostream &os)
+static void serialize(const MetadataCollection& metadata, std::ostream &os)
 {
     indent(1, os);
     serialize(SerializeKey::Metadata, os);
@@ -151,13 +242,29 @@ static void serialize(const Collection<Metadata>::type& metadata, std::ostream &
     os << NewLineItemBlock;
 }
 
+/**
+ * \brief Serialize Metadata source map into output stream.
+ * \param metadata  Metadata source map to serialize
+ * \param os        An output stream to serialize into
+ */
+static void serialize(const Collection<SourceMap<Metadata> >::type& metadata, std::ostream &os)
+{
+    indent(1, os);
+    serialize(SerializeKey::Metadata, os);
+    os << ": ";
+
+    serializeSourceMapCollection(metadata, 1, os);
+
+    os << NewLineItemBlock;
+}
+
 /**
  * \brief Serialize Parameters into output stream.
  * \param prarameters   Parameters to serialize.
  * \param level         Level of indentation.
  * \param os            An output stream to serialize into.
  */
-static void serialize(const Collection<Parameter>::type& parameters, size_t level, std::ostream &os)
+static void serialize(const Parameters& parameters, size_t level, std::ostream &os)
 {
     indent(level, os);
     serialize(SerializeKey::Parameters, os);
@@ -166,6 +273,7 @@ static void serialize(const Collection<Parameter>::type& parameters, size_t leve
     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())
@@ -206,7 +314,10 @@ static void serialize(const Collection<Parameter>::type& parameters, size_t leve
             if (!it->values.empty()) {
                 os << "\n";
                 size_t j = 0;
-                for (Collection<Value>::const_iterator val_it = it->values.begin(); val_it != it->values.end(); ++j, ++val_it) {
+
+                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;
@@ -234,13 +345,102 @@ static void serialize(const Collection<Parameter>::type& parameters, size_t leve
     os << "]";
 }
 
+/**
+ * \brief Serialize Parameters source map into output stream.
+ * \param prarameters   Parameters source map to serialize.
+ * \param level         Level of indentation.
+ * \param os            An output stream to serialize into.
+ */
+static void serialize(const Collection<SourceMap<Parameter> >::type& parameters, size_t level, std::ostream &os)
+{
+    indent(level, os);
+    serialize(SerializeKey::Parameters, os);
+    os << ": [";
+
+    if (!parameters.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<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, level + 2, false, 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);
+            os << ": [";
+
+            if (!it->values.collection.empty()) {
+                os << "\n";
+                size_t j = 0;
+
+                indent(level + 3, os);
+
+                for (Collection<SourceMap<Value> >::const_iterator val_it = it->values.collection.begin();
+                     val_it != it->values.collection.end();
+                     ++j, ++val_it) {
+
+                    if (j > 0 && j < it->values.collection.size())
+                        os << NewLineItemBlock;
+
+                    serialize(*val_it, level + 3, 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 << "]";
+}
+
 /**
  * \brief Serialize HTTP headers into output stream.
  * \param headers   Headers to serialize.
  * \param level Level of indentation.
  * \param os    An output stream to serialize into.
  */
-static void serialize(const Collection<Header>::type& headers, size_t level, std::ostream &os)
+static void serialize(const Headers& headers, size_t level, std::ostream &os)
 {
     indent(level, os);
     serialize(SerializeKey::Headers, os);
@@ -249,6 +449,21 @@ static void serialize(const Collection<Header>::type& headers, size_t level, std
     serializeKeyValueCollection(headers, level, os);
 }
 
+/**
+ * \brief Serialize HTTP headers source map into output stream.
+ * \param headers   Headers source map to serialize.
+ * \param level Level of indentation.
+ * \param os    An output stream to serialize into.
+ */
+static void serialize(const Collection<SourceMap<Header> >::type& headers, size_t level, std::ostream &os)
+{
+    indent(level, os);
+    serialize(SerializeKey::Headers, os);
+    os << ": ";
+
+    serializeSourceMapCollection(headers, level, os);
+}
+
 /**
  * \brief Serialize a payload into output stream.
  * \param payload   A payload to serialize.
@@ -257,11 +472,23 @@ static void serialize(const Collection<Header>::type& headers, size_t level, std
 static void serialize(const Payload& payload, size_t level, std::ostream &os)
 {
     os << "{\n";
-    
+
     // Name
     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;
+    }
+
     // Description
     serialize(SerializeKey::Description, payload.description, level + 1, false, os);
     os << NewLineItemBlock;
@@ -282,6 +509,45 @@ static void serialize(const Payload& payload, size_t level, std::ostream &os)
     os << "}";
 }
 
+/**
+ * \brief Serialize a payload source map into output stream.
+ * \param payload   A payload source map to serialize.
+ * \param os    An output stream to serialize into.
+ */
+static void serialize(const SourceMap<Payload>& payload, size_t level, std::ostream &os)
+{
+    os << "{\n";
+
+    // Name
+    serialize(SerializeKey::Name, payload.name, level + 1, false, os);
+    os << NewLineItemBlock;
+
+    // Symbol Reference
+    if (!payload.symbol.sourceMap.empty()) {
+        serialize(SerializeKey::Reference, payload.symbol, level + 1, false, os);
+        os << NewLineItemBlock;
+    }
+
+    // Description
+    serialize(SerializeKey::Description, payload.description, level + 1, false, os);
+    os << NewLineItemBlock;
+
+    // Headers
+    serialize(payload.headers.collection, 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);
+
+    os << "\n";
+    indent(level, os);
+    os << "}";
+}
+
 /**
  * \brief Serialize a transaction example into output stream.
  * \param transaction   A transaction example to serialize.
@@ -309,6 +575,7 @@ static void serialize(const TransactionExample& example, std::ostream &os)
     if (!example.requests.empty()) {
         os << "\n";
         size_t i = 0;
+
         for (Collection<Request>::const_iterator it = example.requests.begin();
              it != example.requests.end();
              ++i, ++it) {
@@ -335,6 +602,7 @@ static void serialize(const TransactionExample& example, std::ostream &os)
     if (!example.responses.empty()) {
         os << "\n";
         size_t i = 0;
+
         for (Collection<Response>::const_iterator it = example.responses.begin();
              it != example.responses.end();
              ++i, ++it) {
@@ -357,6 +625,83 @@ static void serialize(const TransactionExample& example, std::ostream &os)
     os << "}";
 }
 
+/**
+ * \brief Serialize a transaction example source map into output stream.
+ * \param transaction   A transaction example source map to serialize.
+ * \param os            An output stream to serialize into.
+ */
+static void serialize(const SourceMap<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.collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<Request> >::const_iterator it = example.requests.collection.begin();
+             it != example.requests.collection.end();
+             ++i, ++it) {
+
+            if (i > 0 && i < example.requests.collection.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.collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<Response> >::const_iterator it = example.responses.collection.begin();
+             it != example.responses.collection.end();
+             ++i, ++it) {
+
+            if (i > 0 && i < example.responses.collection.size())
+                os << NewLineItemBlock;
+
+            indent(10, os);
+            serialize(*it, 10, os);
+        }
+
+        os << "\n";
+        indent(9, os);
+    }
+    os << "]";
+
+    // Close the transaction
+    os << "\n";
+    indent(8, os);
+    os << "}";
+}
+
 /**
  * \brief Serialize an action into output stream.
  * \param action    The action to serialize.
@@ -392,6 +737,7 @@ static void serialize(const Action& action, std::ostream &os)
     if (!action.examples.empty()) {
         os << "\n";
         size_t i = 0;
+
         for (Collection<TransactionExample>::const_iterator it = action.examples.begin();
              it != action.examples.end();
              ++i, ++it) {
@@ -415,7 +761,65 @@ static void serialize(const Action& action, std::ostream &os)
 }
 
 /**
- * \brief Serialize a resources into output stream.
+ * \brief Serialize an action source map into output stream.
+ * \param action    The action source map to serialize.
+ * \param os        An output stream to serialize into.
+ */
+static void serialize(const SourceMap<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.collection, 7, os);
+    os << NewLineItemBlock;
+
+    // Transactions
+    indent(7, os);
+    serialize(SerializeKey::Examples, os);
+    os << ": ";
+    os << "[";
+
+    if (!action.examples.collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<TransactionExample> >::const_iterator it = action.examples.collection.begin();
+             it != action.examples.collection.end();
+             ++i, ++it) {
+
+            if (i > 0 && i < action.examples.collection.size())
+                os << NewLineItemBlock;
+
+            serialize(*it, os);
+        }
+
+        os << "\n";
+        indent(7, os);
+    }
+
+    os << "]";
+
+    // Close the action
+    os << "\n";
+    indent(6, os);
+    os << "}";
+}
+
+/**
+ * \brief Serialize a resource into output stream.
  * \param resource     A resource to serialize
  * \param os           An output stream to serialize into
  */
@@ -461,8 +865,8 @@ static void serialize(const Resource& resource, std::ostream &os)
 
     if (!resource.actions.empty()) {
         os << "\n";
-        
         size_t i = 0;
+
         for (Collection<Action>::const_iterator it = resource.actions.begin();
              it != resource.actions.end();
              ++i, ++it) {
@@ -476,6 +880,7 @@ static void serialize(const Resource& resource, std::ostream &os)
         os << "\n";
         indent(5, os);
     }
+
     os << "]";
     
     // Close the resource
@@ -484,6 +889,77 @@ static void serialize(const Resource& resource, std::ostream &os)
     os << "}";    
 }
 
+/**
+ * \brief Serialize a resource source map into output stream.
+ * \param resource     A resource source map to serialize
+ * \param os           An output stream to serialize into
+ */
+static void serialize(const SourceMap<Resource>& resource, std::ostream &os)
+{
+    indent(4, os);
+    os << "{\n";
+
+    // 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);
+    if (resource.model.name.sourceMap.empty()) {
+        os << ": {}";
+    }
+    else {
+        os << ": ";
+
+        serialize(resource.model, 5, os);
+    }
+    os << NewLineItemBlock;
+
+    // Parameters
+    serialize(resource.parameters.collection, 5, os);
+    os << NewLineItemBlock;
+
+    // Actions
+    indent(5, os);
+    serialize(SerializeKey::Actions, os);
+    os << ": ";
+    os << "[";
+
+    if (!resource.actions.collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<Action> >::const_iterator it = resource.actions.collection.begin();
+             it != resource.actions.collection.end();
+             ++i, ++it) {
+
+            if (i > 0 && i < resource.actions.collection.size())
+                os << NewLineItemBlock;
+
+            serialize(*it, os);
+        }
+
+        os << "\n";
+        indent(5, os);
+    }
+
+    os << "]";
+
+    // Close the resource
+    os << "\n";
+    indent(4, os);
+    os << "}";
+}
+
 /**
  * \brief Serialize a group of resources into output stream.
  * \param resourceGroup A group to serialize.
@@ -511,6 +987,7 @@ static void serialize(const ResourceGroup& resourceGroup, std::ostream &os)
     if (!resourceGroup.resources.empty()) {
         os << "\n";
         size_t i = 0;
+
         for (Collection<Resource>::const_iterator it = resourceGroup.resources.begin();
              it != resourceGroup.resources.end();
              ++i, ++it) {
@@ -536,11 +1013,63 @@ static void serialize(const ResourceGroup& resourceGroup, std::ostream &os)
 }
 
 /**
- * \brief Serialize Resource Group into output stream.
- * \param resourceGroup Resource Groups to serialize.
- * \param os            An output stream to serialize into.
+ * \brief Serialize a source map of group of resources into output stream.
+ * \param resourceGroup Source map of a group to serialize.
+ * \brief os    An output stream to serialize into.
  */
-static void serialize(const Collection<ResourceGroup>::type& resourceGroups, std::ostream &os)
+static void serialize(const SourceMap<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.collection.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<Resource> >::const_iterator it = resourceGroup.resources.collection.begin();
+             it != resourceGroup.resources.collection.end();
+             ++i, ++it) {
+
+            if (i > 0 && i < resourceGroup.resources.collection.size())
+                os << NewLineItemBlock;
+
+            serialize(*it, os);
+        }
+
+        if (!resourceGroup.resources.collection.empty()) {
+            os << "\n";
+            indent(3, os);
+        }
+    }
+
+    os << "]";
+
+    // Close the group
+    os << "\n";
+    indent(2, os);
+    os << "}";
+}
+
+/**
+ * \brief Serialize Resource Groups into output stream.
+ * \param resourceGroups Resource Groups to serialize.
+ * \param os             An output stream to serialize into.
+ */
+static void serialize(const ResourceGroups& resourceGroups, std::ostream &os)
 {
     indent(1, os);
     serialize(SerializeKey::ResourceGroups, os);
@@ -550,6 +1079,7 @@ static void serialize(const Collection<ResourceGroup>::type& resourceGroups, std
     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())
@@ -565,6 +1095,37 @@ static void serialize(const Collection<ResourceGroup>::type& resourceGroups, std
     os << "]";
 }
 
+/**
+ * \brief Serialize Resource Groups source map into output stream.
+ * \param resourceGroups Resource Groups source map to serialize.
+ * \param os             An output stream to serialize into.
+ */
+static void serialize(const Collection<SourceMap<ResourceGroup> >::type& resourceGroups, std::ostream &os)
+{
+    indent(1, os);
+    serialize(SerializeKey::ResourceGroups, os);
+    os << ": ";
+    os << "[";
+
+    if (!resourceGroups.empty()) {
+        os << "\n";
+        size_t i = 0;
+
+        for (Collection<SourceMap<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 << "]";
+}
+
 /**
  * \brief Serialize a blueprint into output stream.
  * \param blueprint     The blueprint to serialize.
@@ -595,7 +1156,38 @@ static void serialize(const Blueprint& blueprint, std::ostream &os)
     os << "\n}\n";
 }
 
+/**
+ * \brief Serialize a blueprint source map into output stream.
+ * \param blueprint     The blueprint source map to serialize.
+ * \param os            An output stream to serialize into.
+ */
+static void serialize(const SourceMap<Blueprint>& blueprint, std::ostream &os)
+{
+    os << "{\n";
+
+    // Metadata
+    serialize(blueprint.metadata.collection, os);
+
+    // Name
+    serialize(SerializeKey::Name, blueprint.name, 1, false, os);
+    os << NewLineItemBlock;
+
+    // Description
+    serialize(SerializeKey::Description, blueprint.description, 1, false, os);
+    os << NewLineItemBlock;
+
+    // Resource Groups
+    serialize(blueprint.resourceGroups.collection, os);
+
+    os << "\n}\n";
+}
+
 void snowcrash::SerializeJSON(const snowcrash::Blueprint& blueprint, std::ostream &os)
 {
     serialize(blueprint, os);
 }
+
+void snowcrash::SerializeSourceMapJSON(const snowcrash::SourceMap<snowcrash::Blueprint>& blueprint, std::ostream &os)
+{
+    serialize(blueprint, os);
+}