redsnow 0.0.8

data/ext/snowcrash/src/SectionUtility.h

@@ -0,0 +1,142 @@
+//
+//  SectionUtility.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 11/11/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SECTIONUTILITY_H
+#define SNOWCRASH_SECTIONUTILITY_H
+
+#include "BlockUtility.h"
+#include "ListBlockUtility.h"
+#include "CodeBlockUtility.h"
+
+namespace snowcrash {
+    
+    /**
+     *  Compute expected indentation of a section
+     */
+    FORCEINLINE size_t SectionIndentationLevel(const BlueprintSection& section)
+    {
+        switch (section.type) {
+            case ParameterValuesSectionType:
+                return 2;
+                
+            case BodySectionType:
+            case SchemaSectionType:
+            case HeadersSectionType:    // NOTE: Headers can be potentially both level 0 and 1
+                return 1;
+
+            default:
+                return 0;
+        }
+    }
+    
+    /**
+     *  \brief  Report & skip blocks in a foreign section.
+     *  \param  section     Section including the foreign section.
+     *  \param  cur         A cursor pointing to the beigin of the foreign section.
+     *  \return Standard section parse result pointing AFTER the last block parsed.
+     */
+    template <class T>
+    FORCEINLINE ParseSectionResult HandleForeignSection(const BlueprintSection& section,
+                                                        const BlockIterator& cur,
+                                                        const SourceData& sourceData) {
+        
+        ParseSectionResult result = std::make_pair(Result(), cur);
+        BlockIterator sectionCur = cur;
+        
+        std::stringstream ss;
+        SourceCharactersBlock sourceBlock;
+        
+        // Handle list / list item separately
+        if (sectionCur->type == ListItemBlockBeginType ||
+            sectionCur->type == ListBlockBeginType) {
+            
+            // Skip the list / list item
+            if (sectionCur->type == ListBlockBeginType) {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListBlockBeginType, ListBlockEndType);
+            }
+            else {
+                sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, ListItemBlockBeginType, ListItemBlockEndType);
+            }
+            SectionType type = ClassifyChildrenListBlock<T>(cur, section.bounds.second);
+            
+            // Assemble the message
+            ss << "ignoring ";
+            ss << ((type != UndefinedSectionType) ? SectionName(type) : "unrecognized");
+            ss << " list";
+            if (cur->type == ListItemBlockBeginType)
+                ss << " item";
+            
+            if (type != UndefinedSectionType &&
+                section.hasParent()) {
+                BlueprintSection recognizedSection(type, std::make_pair(cur, sectionCur), section.parent());
+                size_t level = SectionIndentationLevel(recognizedSection);
+                
+                if (level) {
+                    ss << ", " << SectionName(type) << " list ";
+                    if (cur->type == ListItemBlockBeginType)
+                        ss << "item ";
+                    ss << "is expected to be indented by ";
+                    ss << level * 4 << " spaces or " << level << " tab";
+                }
+            }
+            
+            sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, sourceData);
+            sectionCur = CloseList(sectionCur, section.bounds.second);
+        }
+        else if (sectionCur->type == QuoteBlockBeginType) {
+            
+            // Skip quote or just one block
+            ss << "ignoring unrecognized quote";
+            sectionCur = SkipToClosingBlock(sectionCur, section.bounds.second, QuoteBlockBeginType, QuoteBlockEndType);
+            sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, sourceData);
+            
+            if (!CheckCursor(section, sectionCur, sourceData, result.first))
+                return result;
+            
+            ++sectionCur;
+        }
+        else {
+            // Skip just one block
+            ss << "ignoring unrecognized block";
+            sourceBlock = CharacterMapForBlock(sectionCur, cur, section.bounds, sourceData);
+            
+            ++sectionCur;
+        }
+
+        
+        if (section.hasParent()) {
+            // Additional hint for some sections
+            switch (section.parent().type) {
+                case ParametersSectionType:
+                    ss << ", expected parameter discussion, e.g. '<parameter name> ... lorem ipsum'";
+                    break;
+
+                case ParameterDefinitionSectionType:
+                    ss << ", expected enumeration of parameter values, e.g. 'Values' followed by a nested list of possbile values";
+                    break;
+                    
+                case ActionSectionType:
+                    ss << ", expected request, response, parameters, headers or a defintion of the next action, resource or a group";
+                    break;
+                    
+                default:
+                    break;
+            }
+        }
+        
+        // WARN: Ignoring unrecognized block
+        result.first.warnings.push_back(Warning(ss.str(),
+                                                IgnoringWarning,
+                                                sourceBlock));
+        
+        result.second = sectionCur;
+        return result;
+    }
+}
+
+#endif

data/ext/snowcrash/src/Serialize.cc

@@ -0,0 +1,52 @@
+//
+//  Serialize.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include "Serialize.h"
+#include "StringUtility.h"
+
+using namespace snowcrash;
+
+const std::string SerializeKey::ASTVersion = "_version";
+const std::string SerializeKey::Metadata = "metadata";
+const std::string SerializeKey::Name = "name";
+const std::string SerializeKey::Description = "description";
+const std::string SerializeKey::ResourceGroups = "resourceGroups";
+const std::string SerializeKey::Resources = "resources";
+const std::string SerializeKey::URI = "uri";
+const std::string SerializeKey::URITemplate = "uriTemplate";
+const std::string SerializeKey::Actions = "actions";
+const std::string SerializeKey::Action = "action";
+const std::string SerializeKey::Method = "method";
+const std::string SerializeKey::Examples = "examples";
+const std::string SerializeKey::Requests = "requests";
+const std::string SerializeKey::Responses = "responses";
+const std::string SerializeKey::Body = "body";
+const std::string SerializeKey::Schema = "schema";
+const std::string SerializeKey::Headers = "headers";
+const std::string SerializeKey::Model = "model";
+const std::string SerializeKey::Value = "value";
+const std::string SerializeKey::Parameters = "parameters";
+const std::string SerializeKey::Type = "type";
+const std::string SerializeKey::Required = "required";
+const std::string SerializeKey::Default = "default";
+const std::string SerializeKey::Example = "example";
+const std::string SerializeKey::Values = "values";
+
+std::string snowcrash::EscapeNewlines(const std::string& input)
+{
+    return ReplaceString(input, "\n", "\\n");
+}
+
+std::string snowcrash::EscapeDoubleQuotes(const std::string& input)
+{
+    return ReplaceString(input, "\"", "\\\"");
+}

data/ext/snowcrash/src/Serialize.h

@@ -0,0 +1,69 @@
+//
+//  Serialize.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SERIALIZE_H
+#define SNOWCRASH_SERIALIZE_H
+
+#include <string>
+
+/** Version of API Blueprint AST serialization */
+#define AST_SERIALIZATION_VERSION "2.0"
+
+namespace snowcrash {
+    
+    /**
+     *  \brief  Escape new lines in input string.
+     *  \param  input   A string to escape its new lines.
+     *  \return A new string with lines escaped.
+     *
+     *  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
+     */
+    struct SerializeKey {
+        static const std::string ASTVersion;
+        static const std::string Metadata;
+        static const std::string Name;
+        static const std::string Description;
+        static const std::string ResourceGroups;
+        static const std::string Resources;
+        static const std::string URI;
+        static const std::string URITemplate;
+        static const std::string Actions;
+        static const std::string Action;
+        static const std::string Examples;
+        static const std::string Transaction;
+        static const std::string Method;
+        static const std::string Requests;
+        static const std::string Responses;
+        static const std::string Body;
+        static const std::string Schema;
+        static const std::string Headers;
+        static const std::string Model;
+        static const std::string Value;
+        static const std::string Parameters;
+        static const std::string Type;
+        static const std::string Required;
+        static const std::string Default;
+        static const std::string Example;
+        static const std::string Values;
+
+    };
+}
+
+#endif

data/ext/snowcrash/src/SerializeJSON.cc

@@ -0,0 +1,601 @@
+//
+//  SerializeJSON.cc
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 4/27/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "SerializeJSON.h"
+#include "Serialize.h"
+
+using namespace snowcrash;
+
+static const std::string IndentBlock = "  ";
+static const std::string NewLineItemBlock = ",\n";
+
+/**
+ * \brief Serialize a JSON string.
+ * \param value    JSON string to serialize
+ * \param os       An output stream to serialize into
+ */
+static void serialize(const std::string& value, std::ostream &os)
+{
+    os << "\"" << value << "\"";
+}
+
+/**
+ * \brief Inserts indentation into an output stream.
+ * \param level    Level of indentation
+ * \param os       An output stream to serialize into
+ */
+static void indent(size_t level, std::ostream &os)
+{
+    for (size_t i = 0; i < level; ++i) {
+        os << IndentBlock;
+    }
+}
+
+/**
+ * \brief Serialize key value pair into output stream.
+ * \param key      Key to serialize
+ * \param value    Value 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 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);
+        os << "}";
+    }
+}
+
+/**
+ * \brief Serialize key boolean value pair into output stream
+ * \param key      Key to serialize
+ * \param value    Value to serialize
+ * \param level    Indentation level
+ * \param os       An output stream to serialize into
+ */
+static void serialize(const std::string& key, bool value, size_t level, std::ostream &os)
+{
+    indent(level, os);
+    serialize(key, os);
+    os << ": ";
+    os << ((value) ? "true" : "false");
+}
+
+/**
+ * \brief Serialize key value pair as an object into output stream
+ * \param key      Key to serialize
+ * \param value    Value to serialize
+ * \param level    Indentation level
+ * \param os       An output stream to serialize into
+ */
+static void serialize(const std::string& key, const std::string& value, size_t level, std::ostream &os)
+{
+    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 << "}";
+}
+
+/**
+ * \brief Serialize an array of key value pairs.
+ * \param collection    Collection to serialize
+ * \param level         Level of indentation
+ * \param os            An output stream to serialize into
+ */
+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)
+{
+    indent(1, os);
+    serialize(SerializeKey::Metadata, os);
+    os << ": ";
+    
+    serializeKeyValueCollection(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)
+{
+    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);
+            os << ": [";
+
+            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) {
+                    
+                    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 << "]";
+}
+
+/**
+ * \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)
+{
+    indent(level, os);
+    serialize(SerializeKey::Headers, os);
+    os << ": ";
+    
+    serializeKeyValueCollection(headers, level, os);
+}
+
+/**
+ * \brief Serialize a payload into output stream.
+ * \param payload   A payload to serialize.
+ * \param os    An output stream to serialize into.
+ */
+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;
+
+    // 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);
+
+    os << "\n";
+    indent(level, os);
+    os << "}";
+}
+
+/**
+ * \brief Serialize a transaction example into output stream.
+ * \param transaction   A transaction example to serialize.
+ * \param os            An output stream to serialize into.
+ */
+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;
+        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;
+        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);
+    os << "}";
+}
+
+/**
+ * \brief Serialize an action into output stream.
+ * \param action    The action to serialize.
+ * \param os        An output stream to serialize into.
+ */
+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;
+        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);
+    os << "}";
+}
+
+/**
+ * \brief Serialize a resources into output stream.
+ * \param resource     A resource to serialize
+ * \param os           An output stream to serialize into
+ */
+static void serialize(const 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.empty()) {
+        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);
+    os << ": ";
+    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) {
+            
+            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 << "}";    
+}
+
+/**
+ * \brief Serialize a group of resources into output stream.
+ * \param resourceGroup A group to serialize.
+ * \brief os    An output stream to serialize into.
+ */
+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;
+        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);
+    os << "}";
+}
+
+/**
+ * \brief Serialize Resource Group into output stream.
+ * \param resourceGroup Resource Groups to serialize.
+ * \param os            An output stream to serialize into.
+ */
+static void serialize(const Collection<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<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.
+ * \param os            An output stream to serialize into.
+ */
+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);
+
+    // 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, os);
+    
+    os << "\n}\n";
+}
+
+void snowcrash::SerializeJSON(const snowcrash::Blueprint& blueprint, std::ostream &os)
+{
+    serialize(blueprint, os);
+}