redsnow 0.3.7 → 0.4.0

data/ext/drafter/ext/sos/src/sosYAML.h

@@ -0,0 +1,104 @@
+//
+//  sosYAML.h
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 12/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SOS_YAML_H
+#define SOS_YAML_H
+
+#include "sos.h"
+
+namespace sos {
+
+    struct SerializeYAML : public Serialize {
+
+        virtual void indent(size_t level, std::ostream& os) {
+
+            for (size_t i = 0; i < level; ++i) {
+                os << "  ";
+            }
+        }
+
+        virtual void null(std::ostream& os) {
+
+            os << " " << "null";
+        }
+
+        virtual void string(const std::string& value, std::ostream& os) {
+
+            std::string normalized = escapeDoubleQuotes(value);
+            normalized = escapeNewlines(normalized);
+
+            os << " " << "\"" << normalized << "\"";
+        }
+
+        virtual void number(double value, std::ostream& os) {
+
+            os << " " << value;
+        }
+
+        virtual void boolean(bool value, std::ostream& os) {
+
+            os << " " << (value ? "true" : "false");
+        }
+
+        virtual void array(const Base& value, std::ostream& os, size_t level) {
+
+            if (!value.array().empty()) {
+
+                if (level > 0) {
+                    os << "\n";
+                }
+
+                size_t i = 0;
+
+                for (Bases::const_iterator it = value.array().begin(); it != value.array().end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.array().size()) {
+                        os << "\n";
+                    }
+
+                    indent(level, os);
+                    os << "-";
+                    process(*it, os, level + 1);
+                }
+            }
+            else {
+                os << " []";
+            }
+        }
+
+        virtual void object(const Base& value, std::ostream& os, size_t level) {
+
+            if (!value.keys.empty()) {
+
+                if (level > 0) {
+                    os << "\n";
+                }
+
+                size_t i = 0;
+
+                for (Keys::const_iterator it = value.keys.begin(); it != value.keys.end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.keys.size()) {
+                        os << "\n";
+                    }
+                    
+                    indent(level, os);
+                    os << *it;
+                    
+                    os << ":";
+                    process(value.object().at(*it), os, level + 1);
+                }
+            }
+            else {
+                os << " {}";
+            }
+        }
+    };
+}
+
+#endif

data/ext/{snowcrash → drafter}/src/Serialize.cc

@@ -1,21 +1,16 @@
 //
 //  Serialize.cc
-//  snowcrash
+//  drafter
 //
 //  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;
+using namespace drafter;
 
-const std::string SerializeKey::ASTVersion = "_version";
 const std::string SerializeKey::Metadata = "metadata";
 const std::string SerializeKey::Reference = "reference";
 const std::string SerializeKey::Id = "id";
@@ -25,8 +20,11 @@ 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::Assets = "assets";
 const std::string SerializeKey::Actions = "actions";
 const std::string SerializeKey::Action = "action";
+const std::string SerializeKey::Relation = "relation";
+const std::string SerializeKey::Attributes = "attributes";
 const std::string SerializeKey::Method = "method";
 const std::string SerializeKey::Examples = "examples";
 const std::string SerializeKey::Requests = "requests";
@@ -43,12 +41,29 @@ 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");
-}
+const std::string SerializeKey::Source = "source";
+const std::string SerializeKey::Resolved = "resolved";
 
-std::string snowcrash::EscapeDoubleQuotes(const std::string& input)
-{
-    return ReplaceString(input, "\"", "\\\"");
-}
+const std::string SerializeKey::Literal = "literal";
+const std::string SerializeKey::Variable = "variable";
+const std::string SerializeKey::TypeDefinition = "typeDefinition";
+const std::string SerializeKey::TypeSpecification = "typeSpecification";
+const std::string SerializeKey::NestedTypes = "nestedTypes";
+const std::string SerializeKey::Sections = "sections";
+const std::string SerializeKey::Class = "class";
+const std::string SerializeKey::Content = "content";
+const std::string SerializeKey::ValueDefinition = "valueDefinition";
+
+const std::string SerializeKey::Element = "element";
+const std::string SerializeKey::Role = "role";
+
+const std::string SerializeKey::Version = "_version";
+const std::string SerializeKey::Ast = "ast";
+const std::string SerializeKey::SourceMap= "sourcemap";
+const std::string SerializeKey::Error = "error";
+const std::string SerializeKey::Warnings = "warnings";
+const std::string SerializeKey::AnnotationCode = "code";
+const std::string SerializeKey::AnnotationMessage = "message";
+const std::string SerializeKey::AnnotationLocation = "location";
+const std::string SerializeKey::AnnotationLocationIndex = "index";
+const std::string SerializeKey::AnnotationLocationLength = "length";

data/ext/drafter/src/Serialize.h

@@ -0,0 +1,135 @@
+//
+//  Serialize.h
+//  drafter
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_SERIALIZE_H
+#define DRAFTER_SERIALIZE_H
+
+#include <string>
+#include "BlueprintSourcemap.h"
+#include "sos.h"
+
+/** Version of API Blueprint serialization */
+#define AST_SERIALIZATION_VERSION "3.0"
+#define PARSE_RESULT_SERIALIZATION_VERSION "2.1"
+
+namespace drafter {
+
+    /**
+     *  AST entities serialization keys
+     */
+    struct SerializeKey {
+        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;
+        static const std::string Resources;
+        static const std::string URI;
+        static const std::string URITemplate;
+        static const std::string Assets;
+        static const std::string Actions;
+        static const std::string Action;
+        static const std::string Relation;
+        static const std::string Attributes;
+        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;
+
+        static const std::string Source;
+        static const std::string Resolved;
+
+        static const std::string Literal;
+        static const std::string Variable;
+        static const std::string TypeDefinition;
+        static const std::string TypeSpecification;
+        static const std::string NestedTypes;
+        static const std::string Sections;
+        static const std::string Class;
+        static const std::string Content;
+        static const std::string ValueDefinition;
+
+        static const std::string Element;
+        static const std::string Role;
+
+        static const std::string Version;
+        static const std::string Ast;
+        static const std::string SourceMap;
+        static const std::string Error;
+        static const std::string Warnings;
+        static const std::string AnnotationCode;
+        static const std::string AnnotationMessage;
+        static const std::string AnnotationLocation;
+        static const std::string AnnotationLocationIndex;
+        static const std::string AnnotationLocationLength;
+    };
+
+
+    /**
+     * \brief functor pattern to translate _collection_ into sos::Array on serialization 
+     * \requests for collection - must define typedef member ::const_iterator
+     *
+     * usage:
+     *
+     * sos::Array elements = WrapCollection<mson::Element>()(getSomeListOfElements(), WrapMSONElement));
+     *
+     * operator()(const T& collection, Functor &wrapper)
+     * \param collection - it come typicaly from snowcrash
+     * \param wrapper - adaptee element before push to collection
+     *        you have to write your own, for example \see SeriallizeAST.cc
+     *
+     */
+    template<typename T, typename R = sos::Array>
+    struct WrapCollection {
+
+        typedef T value_type;
+
+        template<typename Collection, typename Functor>
+        R operator()(const Collection& collection, Functor &wrapper) const {
+            typedef typename Collection::const_iterator iterator_type;
+            R array;
+
+            for (iterator_type it = collection.begin(); it != collection.end(); ++it) {
+                array.push(wrapper(*it));
+            }
+
+            return array;
+        }
+
+        template<typename Collection, typename Functor, typename Predicate>
+        R operator()(const Collection& collection, Functor &wrapper, Predicate &predicate) const {
+            typedef typename Collection::const_iterator iterator_type;
+            R array;
+
+            for (iterator_type it = collection.begin(); it != collection.end(); ++it) {
+                if (predicate(*it)) {
+                    array.push(wrapper(*it));
+                }
+            }
+
+            return array;
+        }
+
+    };
+
+}
+
+#endif

data/ext/drafter/src/SerializeAST.cc

@@ -0,0 +1,775 @@
+//
+//  SerializeAST.cc
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 18/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "StringUtility.h"
+#include "SerializeAST.h"
+
+using namespace drafter;
+
+using snowcrash::AssetRole;
+using snowcrash::BodyExampleAssetRole;
+using snowcrash::BodySchemaAssetRole;
+
+using snowcrash::Element;
+using snowcrash::Elements;
+using snowcrash::KeyValuePair;
+using snowcrash::Metadata;
+using snowcrash::Header;
+using snowcrash::Reference;
+using snowcrash::DataStructure;
+using snowcrash::Asset;
+using snowcrash::Payload;
+using snowcrash::Value;
+using snowcrash::Parameter;
+using snowcrash::TransactionExample;
+using snowcrash::Request;
+using snowcrash::Response;
+using snowcrash::Action;
+using snowcrash::Resource;
+using snowcrash::Blueprint;
+
+sos::Object WrapValue(const mson::Value& value)
+{
+    sos::Object valueObject;
+
+    // Literal
+    valueObject.set(SerializeKey::Literal, sos::String(value.literal));
+
+    // Variable
+    valueObject.set(SerializeKey::Variable, sos::Boolean(value.variable));
+
+    return valueObject;
+}
+
+sos::Object WrapSymbol(const mson::Symbol& symbol)
+{
+    sos::Object symbolObject;
+
+    // Literal
+    symbolObject.set(SerializeKey::Literal, sos::String(symbol.literal));
+
+    // Variable
+    symbolObject.set(SerializeKey::Variable, sos::Boolean(symbol.variable));
+
+    return symbolObject;
+}
+
+sos::Base WrapTypeName(const mson::TypeName& typeName)
+{
+    if (typeName.empty()) {
+        return sos::Null();
+    }
+
+    if (typeName.base != mson::UndefinedTypeName) {
+
+        std::string baseTypeName;
+
+        switch (typeName.base) {
+
+            case mson::BooleanTypeName:
+                baseTypeName = "boolean";
+                break;
+
+            case mson::StringTypeName:
+                baseTypeName = "string";
+                break;
+
+            case mson::NumberTypeName:
+                baseTypeName = "number";
+                break;
+
+            case mson::ArrayTypeName:
+                baseTypeName = "array";
+                break;
+
+            case mson::EnumTypeName:
+                baseTypeName = "enum";
+                break;
+
+            case mson::ObjectTypeName:
+                baseTypeName = "object";
+                break;
+
+            default:
+                break;
+        }
+
+        return sos::String(baseTypeName);
+    }
+
+    return WrapSymbol(typeName.symbol);
+}
+
+
+sos::Object WrapTypeSpecification(const mson::TypeSpecification& typeSpecification)
+{
+    sos::Object typeSpecificationObject;
+
+    // Name
+    typeSpecificationObject.set(SerializeKey::Name, WrapTypeName(typeSpecification.name));
+
+    // Nested Types
+    typeSpecificationObject.set(SerializeKey::NestedTypes, 
+                                WrapCollection<mson::TypeName>()(typeSpecification.nestedTypes, WrapTypeName));
+
+    return typeSpecificationObject;
+}
+
+sos::Array WrapTypeAttributes(const mson::TypeAttributes& typeAttributes)
+{
+    sos::Array typeAttributesArray;
+
+    if (typeAttributes & mson::RequiredTypeAttribute) {
+        typeAttributesArray.push(sos::String("required"));
+    }
+    else if (typeAttributes & mson::OptionalTypeAttribute) {
+        typeAttributesArray.push(sos::String("optional"));
+    }
+    else if (typeAttributes & mson::DefaultTypeAttribute) {
+        typeAttributesArray.push(sos::String("default"));
+    }
+    else if (typeAttributes & mson::SampleTypeAttribute) {
+        typeAttributesArray.push(sos::String("sample"));
+    }
+    else if (typeAttributes & mson::FixedTypeAttribute) {
+        typeAttributesArray.push(sos::String("fixed"));
+    }
+
+    return typeAttributesArray;
+}
+
+sos::Object WrapTypeDefinition(const mson::TypeDefinition& typeDefinition)
+{
+    sos::Object typeDefinitionObject;
+
+    // Type Specification
+    typeDefinitionObject.set(SerializeKey::TypeSpecification, WrapTypeSpecification(typeDefinition.typeSpecification));
+
+    // Type Attributes
+    typeDefinitionObject.set(SerializeKey::Attributes, WrapTypeAttributes(typeDefinition.attributes));
+
+    return typeDefinitionObject;
+}
+
+sos::Object WrapValueDefinition(const mson::ValueDefinition& valueDefinition)
+{
+    sos::Object valueDefinitionObject;
+
+    // Values
+    valueDefinitionObject.set(SerializeKey::Values,
+                              WrapCollection<mson::Value>()(valueDefinition.values, WrapValue));
+
+    // Type Definition
+    valueDefinitionObject.set(SerializeKey::TypeDefinition, WrapTypeDefinition(valueDefinition.typeDefinition));
+
+    return valueDefinitionObject;
+}
+
+sos::Object WrapPropertyName(const mson::PropertyName& propertyName)
+{
+    sos::Object propertyNameObject;
+
+    if (!propertyName.literal.empty()) {
+        propertyNameObject.set(SerializeKey::Literal, sos::String(propertyName.literal));
+    }
+    else if (!propertyName.variable.empty()) {
+        propertyNameObject.set(SerializeKey::Variable, WrapValueDefinition(propertyName.variable));
+    }
+
+    return propertyNameObject;
+}
+
+// Forward declarations
+sos::Object WrapTypeSection(const mson::TypeSection& typeSection);
+
+const sos::String TypeSectionClassToString(const mson::TypeSection::Class& klass)
+{
+    switch (klass) {
+        case mson::TypeSection::BlockDescriptionClass:
+            return sos::String("blockDescription");
+
+        case mson::TypeSection::MemberTypeClass:
+            return sos::String("memberType");
+
+        case mson::TypeSection::SampleClass:
+            return sos::String("sample");
+
+        case mson::TypeSection::DefaultClass:
+            return sos::String("default");
+
+        default:
+            return sos::String();
+    }
+
+    return sos::String();
+}
+
+sos::String AssetRoleToString(const AssetRole& role)
+{
+    std::string str;
+
+    switch (role) {
+        case BodyExampleAssetRole:
+            str = "bodyExample";
+            break;
+
+        case BodySchemaAssetRole:
+            str = "bodySchema";
+            break;
+
+        default:
+            break;
+    }
+
+    return sos::String(str);
+}
+
+sos::String ElementClassToString(const Element::Class& element)
+{
+    std::string str;
+
+    switch (element) {
+        case Element::CategoryElement:
+            str = "category";
+            break;
+
+        case Element::CopyElement:
+            str = "copy";
+            break;
+
+        case Element::ResourceElement:
+            str = "resource";
+            break;
+
+        case Element::DataStructureElement:
+            str = "dataStructure";
+            break;
+
+        case Element::AssetElement:
+            str = "asset";
+            break;
+
+        default:
+            break;
+    }
+
+    return sos::String(str);
+}
+
+sos::Object WrapNamedType(const mson::NamedType& namedType)
+{
+    sos::Object namedTypeObject;
+
+    // Name
+    namedTypeObject.set(SerializeKey::Name, WrapTypeName(namedType.name));
+
+    // Type Definition
+    namedTypeObject.set(SerializeKey::TypeDefinition, WrapTypeDefinition(namedType.typeDefinition));
+
+    // Type Sections
+    namedTypeObject.set(SerializeKey::Sections, 
+                        WrapCollection<mson::TypeSection>()(namedType.sections, WrapTypeSection));
+
+    return namedTypeObject;
+}
+
+sos::Object WrapKeyValue(const KeyValuePair& keyValue)
+{
+    sos::Object keyValueObject;
+
+    // Name
+    keyValueObject.set(SerializeKey::Name, sos::String(keyValue.first));
+
+    // Value
+    keyValueObject.set(SerializeKey::Value, sos::String(keyValue.second));
+
+    return keyValueObject;
+}
+
+sos::Object WrapMetadata(const Metadata& metadata)
+{
+    return WrapKeyValue(metadata);
+}
+
+sos::Object WrapHeader(const Header& header)
+{
+    return WrapKeyValue(header);
+}
+
+sos::Object WrapReference(const Reference& reference)
+{
+    sos::Object referenceObject;
+
+    // Id
+    referenceObject.set(SerializeKey::Id, sos::String(reference.id));
+
+    return referenceObject;
+}
+
+sos::Object WrapPropertyMember(const mson::PropertyMember& propertyMember)
+{
+    sos::Object propertyMemberObject;
+
+    // Name
+    propertyMemberObject.set(SerializeKey::Name, WrapPropertyName(propertyMember.name));
+
+    // Description
+    propertyMemberObject.set(SerializeKey::Description, sos::String(propertyMember.description));
+
+    // Value Definition
+    propertyMemberObject.set(SerializeKey::ValueDefinition, WrapValueDefinition(propertyMember.valueDefinition));
+
+    // Type Sections
+    propertyMemberObject.set(SerializeKey::Sections,
+                             WrapCollection<mson::TypeSection>()(propertyMember.sections, WrapTypeSection));
+
+    return propertyMemberObject;
+}
+
+sos::Object WrapValueMember(const mson::ValueMember& valueMember)
+{
+    sos::Object valueMemberObject;
+
+    // Description
+    valueMemberObject.set(SerializeKey::Description, sos::String(valueMember.description));
+
+    // Value Definition
+    valueMemberObject.set(SerializeKey::ValueDefinition, WrapValueDefinition(valueMember.valueDefinition));
+
+    // Type Sections
+    valueMemberObject.set(SerializeKey::Sections,
+                          WrapCollection<mson::TypeSection>()(valueMember.sections, WrapTypeSection));
+
+    return valueMemberObject;
+}
+
+sos::Object WrapMixin(const mson::Mixin& mixin)
+{
+    return WrapTypeDefinition(mixin);
+}
+
+sos::Object WrapMSONElement(const mson::Element& element)
+{
+    sos::Object elementObject;
+    std::string klass;
+
+    switch (element.klass) {
+
+        case mson::Element::PropertyClass:
+        {
+            klass = "property";
+            elementObject.set(SerializeKey::Content, WrapPropertyMember(element.content.property));
+            break;
+        }
+
+        case mson::Element::ValueClass:
+        {
+            klass = "value";
+            elementObject.set(SerializeKey::Content, WrapValueMember(element.content.value));
+            break;
+        }
+
+        case mson::Element::MixinClass:
+        {
+            klass = "mixin";
+            elementObject.set(SerializeKey::Content, WrapMixin(element.content.mixin));
+            break;
+        }
+
+        case mson::Element::OneOfClass:
+        {
+            klass = "oneOf";
+            elementObject.set(SerializeKey::Content, 
+                              WrapCollection<mson::Element>()(element.content.oneOf(), WrapMSONElement));
+            break;
+        }
+
+        case mson::Element::GroupClass:
+        {
+            klass = "group";
+            elementObject.set(SerializeKey::Content, 
+                              WrapCollection<mson::Element>()(element.content.elements(), WrapMSONElement));
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    elementObject.set(SerializeKey::Class, sos::String(klass));
+
+    return elementObject;
+}
+
+sos::Object WrapTypeSection(const mson::TypeSection& section)
+{
+    sos::Object object;
+
+    // Class
+    object.set(SerializeKey::Class, TypeSectionClassToString(section.klass));
+
+    // Content
+    if (!section.content.description.empty()) {
+        object.set(SerializeKey::Content, sos::String(section.content.description));
+    }
+    else if (!section.content.value.empty()) {
+        object.set(SerializeKey::Content, sos::String(section.content.value));
+    }
+    else if (!section.content.elements().empty()) {
+        object.set(SerializeKey::Content, 
+                   WrapCollection<mson::Element>()(section.content.elements(), WrapMSONElement));
+    }
+
+    return object;
+}
+
+sos::Object WrapDataStructure(const DataStructure& dataStructure)
+{
+    sos::Object dataStructureObject;
+
+    // Element
+    dataStructureObject.set(SerializeKey::Element, ElementClassToString(Element::DataStructureElement));
+
+    // Name
+    dataStructureObject.set(SerializeKey::Name, WrapTypeName(dataStructure.name));
+
+    // Type Definition
+    dataStructureObject.set(SerializeKey::TypeDefinition, WrapTypeDefinition(dataStructure.typeDefinition));
+
+    // Type Sections
+    dataStructureObject.set(SerializeKey::Sections,
+                            WrapCollection<mson::TypeSection>()(dataStructure.sections, WrapTypeSection));
+
+    return dataStructureObject;
+}
+
+sos::Object WrapAsset(const Asset& asset, const AssetRole& role)
+{
+    sos::Object assetObject;
+
+    // Element
+    assetObject.set(SerializeKey::Element, ElementClassToString(Element::AssetElement));
+
+    // Attributes
+    sos::Object attributes;
+
+    /// Role
+    attributes.set(SerializeKey::Role, AssetRoleToString(role));
+
+    assetObject.set(SerializeKey::Attributes, attributes);
+
+    // Content
+    assetObject.set(SerializeKey::Content, sos::String(asset));
+
+    return assetObject;
+}
+
+sos::Object WrapPayload(const Payload& payload)
+{
+    sos::Object payloadObject;
+
+    // Reference
+    if (!payload.reference.id.empty()) {
+        payloadObject.set(SerializeKey::Reference, WrapReference(payload.reference));
+    }
+
+    // Name
+    payloadObject.set(SerializeKey::Name, sos::String(payload.name));
+
+    // Description
+    payloadObject.set(SerializeKey::Description, sos::String(payload.description));
+
+    // Headers
+    payloadObject.set(SerializeKey::Headers,
+                      WrapCollection<Header>()(payload.headers, WrapHeader));
+
+    // Body
+    payloadObject.set(SerializeKey::Body, sos::String(payload.body));
+
+    // Schema
+    payloadObject.set(SerializeKey::Schema, sos::String(payload.schema));
+
+    // Content
+    sos::Array content;
+
+    /// Attributes
+    if (!payload.attributes.empty()) {
+        content.push(WrapDataStructure(payload.attributes));
+    }
+
+    /// Asset 'bodyExample'
+    if (!payload.body.empty()) {
+        content.push(WrapAsset(payload.body, BodyExampleAssetRole));
+    }
+
+    /// Asset 'bodySchema'
+    if (!payload.schema.empty()) {
+        content.push(WrapAsset(payload.schema, BodySchemaAssetRole));
+    }
+
+    payloadObject.set(SerializeKey::Content, content);
+
+    return payloadObject;
+}
+
+sos::Object WrapParameterValue(const Value& value)
+{
+    sos::Object object;
+    object.set(SerializeKey::Value, sos::String(value.c_str()));
+
+    return object;
+}
+
+sos::Object WrapParameter(const Parameter& parameter)
+{
+    sos::Object parameterObject;
+
+    // Name
+    parameterObject.set(SerializeKey::Name, sos::String(parameter.name));
+
+    // Description
+    parameterObject.set(SerializeKey::Description, sos::String(parameter.description));
+
+    // Type
+    parameterObject.set(SerializeKey::Type, sos::String(parameter.type));
+
+    // Use
+    parameterObject.set(SerializeKey::Required, sos::Boolean(parameter.use != snowcrash::OptionalParameterUse));
+
+    // Default Value
+    parameterObject.set(SerializeKey::Default, sos::String(parameter.defaultValue));
+
+    // Example Value
+    parameterObject.set(SerializeKey::Example, sos::String(parameter.exampleValue));
+
+    // Values
+    parameterObject.set(SerializeKey::Values, 
+                        WrapCollection<Value>()(parameter.values, WrapParameterValue));
+
+    return parameterObject;
+}
+
+sos::Object WrapTransactionExample(const TransactionExample& example)
+{
+    sos::Object exampleObject;
+
+    // Name
+    exampleObject.set(SerializeKey::Name, sos::String(example.name));
+
+    // Description
+    exampleObject.set(SerializeKey::Description, sos::String(example.description));
+
+    // Requests
+    exampleObject.set(SerializeKey::Requests,
+                      WrapCollection<Request>()(example.requests, WrapPayload));
+
+    // Responses
+    exampleObject.set(SerializeKey::Responses,
+                      WrapCollection<Response>()(example.responses, WrapPayload));
+
+    return exampleObject;
+}
+
+sos::Object WrapAction(const Action& action)
+{
+    sos::Object actionObject;
+
+    // Name
+    actionObject.set(SerializeKey::Name, sos::String(action.name));
+
+    // Description
+    actionObject.set(SerializeKey::Description, sos::String(action.description));
+
+    // HTTP Method
+    actionObject.set(SerializeKey::Method, sos::String(action.method));
+
+    // Parameters
+    actionObject.set(SerializeKey::Parameters,
+                     WrapCollection<Parameter>()(action.parameters, WrapParameter));
+
+    // Attributes
+    sos::Object attributes;
+
+    /// Relation
+    attributes.set(SerializeKey::Relation, sos::String(action.relation.str));
+
+    /// URI Template
+    attributes.set(SerializeKey::URITemplate, sos::String(action.uriTemplate));
+
+    actionObject.set(SerializeKey::Attributes, attributes);
+
+    // Content
+    sos::Array content;
+
+    if (!action.attributes.empty()) {
+        content.push(WrapDataStructure(action.attributes));
+    }
+
+    actionObject.set(SerializeKey::Content, content);
+
+    // Transaction Examples
+    actionObject.set(SerializeKey::Examples,
+                     WrapCollection<TransactionExample>()(action.examples, WrapTransactionExample));
+
+    return actionObject;
+}
+
+sos::Object WrapResource(const Resource& resource)
+{
+    sos::Object resourceObject;
+
+    // Element
+    resourceObject.set(SerializeKey::Element, ElementClassToString(Element::ResourceElement));
+
+    // Name
+    resourceObject.set(SerializeKey::Name, sos::String(resource.name));
+
+    // Description
+    resourceObject.set(SerializeKey::Description, sos::String(resource.description));
+
+    // URI Template
+    resourceObject.set(SerializeKey::URITemplate, sos::String(resource.uriTemplate));
+
+    // Model
+    sos::Object model = (resource.model.name.empty() ? sos::Object() : WrapPayload(resource.model));
+    resourceObject.set(SerializeKey::Model, model);
+
+    // Parameters
+    resourceObject.set(SerializeKey::Parameters,
+                       WrapCollection<Parameter>()(resource.parameters, WrapParameter));
+
+    // Actions
+    resourceObject.set(SerializeKey::Actions,
+                       WrapCollection<Action>()(resource.actions, WrapAction));
+
+    // Content
+    sos::Array content;
+
+    if (!resource.attributes.empty()) {
+        content.push(WrapDataStructure(resource.attributes));
+    }
+
+    resourceObject.set(SerializeKey::Content, content);
+
+    return resourceObject;
+}
+
+sos::Object WrapResourceGroup(const Element& resourceGroup)
+{
+    sos::Object resourceGroupObject;
+
+    // Name
+    resourceGroupObject.set(SerializeKey::Name, sos::String(resourceGroup.attributes.name));
+
+    // Description && Resources
+    std::string description;
+    sos::Array resources;
+
+    for (Elements::const_iterator it = resourceGroup.content.elements().begin();
+         it != resourceGroup.content.elements().end();
+         ++it) {
+
+        if (it->element == Element::ResourceElement) {
+            resources.push(WrapResource(it->content.resource));
+        }
+        else if (it->element == Element::CopyElement) {
+
+            if (!description.empty()) {
+                snowcrash::TwoNewLines(description);
+            }
+
+            description += it->content.copy;
+        }
+    }
+
+    resourceGroupObject.set(SerializeKey::Description, sos::String(description));
+    resourceGroupObject.set(SerializeKey::Resources, resources);
+
+    return resourceGroupObject;
+}
+
+sos::Object WrapElement(const Element& element)
+{
+    sos::Object elementObject;
+
+    elementObject.set(SerializeKey::Element, ElementClassToString(element.element));
+
+    if (!element.attributes.name.empty()) {
+
+        sos::Object attributes;
+
+        attributes.set(SerializeKey::Name, sos::String(element.attributes.name));
+        elementObject.set(SerializeKey::Attributes, attributes);
+    }
+
+    switch (element.element) {
+        case Element::CopyElement:
+        {
+            elementObject.set(SerializeKey::Content, sos::String(element.content.copy));
+            break;
+        }
+
+        case Element::CategoryElement:
+        {
+            elementObject.set(SerializeKey::Content,
+                              WrapCollection<Element>()(element.content.elements(), WrapElement));
+            break;
+        }
+
+        case Element::DataStructureElement:
+        {
+            return WrapDataStructure(element.content.dataStructure);
+        }
+
+        case Element::ResourceElement:
+        {
+            return WrapResource(element.content.resource);
+        }
+
+        default:
+            break;
+    }
+
+    return elementObject;
+}
+
+bool IsElementResourceGroup(const Element& element)
+{
+    return element.element == Element::CategoryElement && element.category == Element::ResourceGroupCategory;
+}
+
+sos::Object drafter::WrapBlueprint(const Blueprint& blueprint)
+{
+    sos::Object blueprintObject;
+
+    // Version
+    blueprintObject.set(SerializeKey::Version, sos::String(AST_SERIALIZATION_VERSION));
+
+    // Metadata
+    blueprintObject.set(SerializeKey::Metadata, 
+                        WrapCollection<Metadata>()(blueprint.metadata, WrapKeyValue));
+
+    // Name
+    blueprintObject.set(SerializeKey::Name, sos::String(blueprint.name));
+
+    // Description
+    blueprintObject.set(SerializeKey::Description, sos::String(blueprint.description));
+
+    // Element
+    blueprintObject.set(SerializeKey::Element, ElementClassToString(blueprint.element));
+
+    // Resource Groups
+    blueprintObject.set(SerializeKey::ResourceGroups, 
+                        WrapCollection<Element>()(blueprint.content.elements(), WrapResourceGroup, IsElementResourceGroup));
+
+    // Content
+    blueprintObject.set(SerializeKey::Content,
+                        WrapCollection<Element>()(blueprint.content.elements(), WrapElement));
+
+    return blueprintObject;
+}