lounge_lizard 0.1.0

data/ext/drafter/src/RefractDataStructure.h

@@ -0,0 +1,26 @@
+//
+//  RefractDataStructure.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 18/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_REFRACTDATASTRUCTURE_H
+#define DRAFTER_REFRACTDATASTRUCTURE_H
+
+#include "Serialize.h"
+
+namespace drafter {
+
+    class ConversionContext;
+
+    refract::IElement* MSONToRefract(const NodeInfo<snowcrash::DataStructure>& dataStructure, ConversionContext& context);
+    refract::IElement* ExpandRefract(refract::IElement* element, ConversionContext& context);
+
+    sos::Object SerializeRefract(refract::IElement*, ConversionContext& context);
+
+}
+
+#endif // #ifndef DRAFTER_REFRACTDATASTRUCTURE_H
+

data/ext/drafter/src/RefractElementFactory.cc

@@ -0,0 +1,107 @@
+#include "RefractElementFactory.h"
+#include "refract/Element.h"
+
+#include "Serialize.h" // LiteralTo<>
+#include "SourceAnnotation.h" // mson::Error
+
+namespace drafter {
+
+    template <typename E, typename V = typename E::ValueType>
+    struct RefractElementFactoryImpl : RefractElementFactory
+    {
+
+        RefractElementFactoryImpl() {}
+
+        virtual refract::IElement* Create(const std::string& literal, FactoryCreateMethod method) const
+        {
+            E* element = new E;
+
+            if (literal.empty()) {
+                return element;
+            }
+
+            switch (method) {
+                case eSample: {
+                        refract::ArrayElement* samples = new refract::ArrayElement;
+                        std::pair<bool, typename E::ValueType> value = LiteralTo<typename E::ValueType>(literal);
+                        if (value.first) {
+                            samples->push_back(refract::IElement::Create(value.second));
+                        }
+                        element->attributes[SerializeKey::Samples] = samples;
+                    }
+                    break;
+
+                case eValue: {
+                        std::pair<bool, V> value = LiteralTo<V>(literal);
+                        if (value.first) {
+                            element->set(value.second);
+                        }
+                    }
+                    break;
+
+                case eElement:
+                    element->element(literal);
+                    break;
+                    
+            }
+
+            return element;
+        }
+    };
+
+    template <typename E>
+    struct RefractElementFactoryImpl<E, refract::RefractElements> : RefractElementFactory
+    {
+
+        RefractElementFactoryImpl() {}
+
+        virtual refract::IElement* Create(const std::string& literal, FactoryCreateMethod method) const
+        {
+            if (method == eSample) {
+                refract::StringElement* element = new refract::StringElement;
+                element->element(SerializeKey::Generic);
+                element->set(literal);
+                return element;
+            }
+
+            E* element = new E;
+
+            if (!literal.empty()) {
+                element->element(literal);
+            }
+
+            return element;
+        }
+    };
+
+    const RefractElementFactory& FactoryFromType(const mson::BaseTypeName typeName)
+    {
+
+        static const RefractElementFactoryImpl<refract::BooleanElement> boolFactory;
+        static const RefractElementFactoryImpl<refract::NumberElement> numberFactory;
+        static const RefractElementFactoryImpl<refract::StringElement> stringFactory;
+        static const RefractElementFactoryImpl<refract::EnumElement> enumFactory;
+        static const RefractElementFactoryImpl<refract::ArrayElement> arrayFactory;
+        static const RefractElementFactoryImpl<refract::ObjectElement> objectFactory;
+
+         switch (typeName) {
+             case mson::BooleanTypeName:
+                return boolFactory;
+             case mson::NumberTypeName:
+                return numberFactory;
+             case mson::StringTypeName:
+                return stringFactory;
+            case mson::ArrayTypeName:
+                return arrayFactory;
+            case mson::EnumTypeName:
+                return enumFactory;
+             case mson::ObjectTypeName:
+             case mson::UndefinedTypeName:
+                return objectFactory;
+             default:
+                 ; // do nothing
+         }
+
+        throw snowcrash::Error("unknown mson type", snowcrash::ApplicationError);
+    }
+}

data/ext/drafter/src/RefractElementFactory.h

@@ -0,0 +1,67 @@
+//
+//  RefractElementFactory.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 04-03-2016
+//  Copyright (c) 2016 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_REFRACTELEMENTFACTORY_H
+#define DRAFTER_REFRACTELEMENTFACTORY_H
+
+#include <string>
+#include "MSON.h"
+
+namespace refract {
+    struct IElement;
+}
+
+namespace drafter {
+
+    /**
+     * This interface is used while conversion from legacy AST
+     * into refract tree.
+     *
+     * For usage see test/test-ElementFactoryTest.cc
+     *
+     * WARNING:
+     * There is little bit different behavior for primitives and for complex elements.
+     *
+     * For any case:
+     * - if `literal` is empty - return __empty__ element of required type
+     *
+     * For primitives (string|number|bool):
+     * - `sample` eValue - return typed element with __value__  set via `ToLiteral<>` conversion
+     * - `sample` eSample - return typed element with __attributes.samples__ set via `ToLiteral<>` conversion
+     * - `sample` eElement - return typed element with set __element name__ to `literal`
+     *
+     * For complex elements (object|array|enum):
+     * - `sample` eSample - return StringElement with name __generic__ with value set to `literal`
+     * - `sample` eValue|eElement - return return typed element with set __element name__ to `literal`
+     *
+     * This inconsistent behavior is determined by rules of converting legacy AST to Refract.
+     *
+     * Code will be deprecated (refactoring or remove) after remove legacy AST.
+     */
+
+    enum FactoryCreateMethod {
+        eValue,
+        eSample,
+        eElement,
+    };
+
+    struct RefractElementFactory
+    {
+        virtual ~RefractElementFactory() {}
+        virtual refract::IElement* Create(const std::string& literal, FactoryCreateMethod type) const = 0;
+    };
+
+    /**
+     * Do not change const return type!!!
+     * it is due to thread safety
+     */
+    const RefractElementFactory& FactoryFromType(const mson::BaseTypeName typeName);
+
+}
+
+#endif /* #ifndef DRAFTER_REFRACTELEMENTFACTORY_H */

data/ext/drafter/src/RefractSourceMap.cc

@@ -0,0 +1,29 @@
+#include "RefractSourceMap.h"
+
+static refract::IElement* CharacterRangeToRefract(const mdp::CharactersRange& sourceMap)
+{
+    refract::ArrayElement* range = new refract::ArrayElement;
+
+    range->push_back(refract::IElement::Create(sourceMap.location));
+    range->push_back(refract::IElement::Create(sourceMap.length));
+
+    return range;
+}
+
+refract::IElement* drafter::SourceMapToRefract(const mdp::CharactersRangeSet& sourceMap)
+{
+    refract::ArrayElement* sourceMapElement = new refract::ArrayElement;
+    sourceMapElement->element(SerializeKey::SourceMap);
+
+    refract::ArrayElement::ValueType ranges;
+    std::transform(sourceMap.begin(), sourceMap.end(), std::back_inserter(ranges), CharacterRangeToRefract);
+
+    sourceMapElement->renderType(refract::IElement::rCompactContent);
+    sourceMapElement->set(ranges);
+
+    refract::ArrayElement* element = new refract::ArrayElement;
+    element->push_back(sourceMapElement);
+
+    return element;
+}
+

data/ext/drafter/src/RefractSourceMap.h

@@ -0,0 +1,57 @@
+//
+//  RefractSourceMap.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 31/07/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_REFRACTSOURCEMAP_H
+#define DRAFTER_REFRACTSOURCEMAP_H
+
+#include "Serialize.h"
+
+namespace drafter {
+
+    refract::IElement* SourceMapToRefract(const mdp::CharactersRangeSet& sourceMap);
+
+    template<typename T>
+    void AttachSourceMap(refract::IElement* element, const T& nodeInfo)
+    {
+        if (!nodeInfo.sourceMap->sourceMap.empty()) {
+            element->attributes[SerializeKey::SourceMap] = SourceMapToRefract(nodeInfo.sourceMap->sourceMap);
+        }
+    }
+
+    template<typename T>
+    refract::IElement* PrimitiveToRefract(const NodeInfo<T>& primitive)
+    {
+        typedef typename refract::ElementTypeSelector<T>::ElementType ElementType;
+
+        ElementType* element = refract::IElement::Create(*primitive.node);
+
+        AttachSourceMap(element, primitive);
+
+        return element;
+    }
+
+    class ConversionContext;
+
+    template<typename T>
+    refract::IElement* LiteralToRefract(const NodeInfo<std::string>& literal, ConversionContext& context)
+    {
+        std::pair<bool, T> parsed = LiteralTo<T>(*literal.node);
+
+        typename refract::ElementTypeSelector<T>::ElementType* element = new typename refract::ElementTypeSelector<T>::ElementType;
+        if (parsed.first) {
+            element->set(parsed.second);
+        }
+
+        AttachSourceMap(element, literal);
+
+        return element;
+    }
+
+}
+
+#endif // #ifndef DRAFTER_REFRACTSOURCEMAP_H

data/ext/drafter/src/Render.cc

@@ -0,0 +1,157 @@
+//
+//  Render.cc
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 18/08/15.
+//  Copyright (c) 2015 Apiary. All rights reserved.
+//
+
+#include "Render.h"
+#include "RefractDataStructure.h"
+
+#include "SourceAnnotation.h"
+#include "BlueprintUtility.h"
+#include "RegexMatch.h"
+
+#include "ConversionContext.h"
+
+#include "refract/RenderJSONVisitor.h"
+#include "refract/JSONSchemaVisitor.h"
+
+using namespace snowcrash;
+
+namespace drafter {
+
+    RenderFormat findRenderFormat(const std::string& contentType) {
+
+        if (RegexMatch(contentType, JSONSchemaRegex)) {
+            return JSONSchemaRenderFormat;
+        }
+        else if (RegexMatch(contentType, JSONRegex)) {
+            return JSONRenderFormat;
+        }
+
+        return UndefinedRenderFormat;
+    }
+
+    std::string getContentTypeFromHeaders(const Headers& headers) {
+        Collection<Header>::const_iterator header;
+
+        header = std::find_if(headers.begin(), headers.end(),
+                              std::bind(MatchFirstWith<Header, std::string>(), std::placeholders::_1, HTTPHeaderName::ContentType));
+
+        if (header != headers.end()) {
+            return header->second;
+        }
+
+        return "";
+    }
+
+    NodeInfoByValue<Asset> renderPayloadBody(const NodeInfo<Payload>& payload,
+                                             const NodeInfo<Action>& action,
+                                             ConversionContext& context) {
+
+        NodeInfoByValue<Asset> body = std::make_pair(payload.node->body, &payload.sourceMap->body);
+
+        NodeInfo<Attributes> payloadAttributes = MAKE_NODE_INFO(payload, attributes);
+        NodeInfo<Attributes> actionAttributes = MAKE_NODE_INFO(action, attributes);
+
+        // hold attributes via pointer - because problems with assignment in NodeInfo<>
+        NodeInfo<Attributes>* attributes = &payloadAttributes;
+
+        if (payload.node->attributes.empty() && !action.isNull() && !action.node->attributes.empty()) {
+           attributes = &actionAttributes;
+        }
+
+        RenderFormat renderFormat = findRenderFormat(getContentTypeFromHeaders(payload.node->headers));
+
+        // Only continue down if we have a render format
+        if (!payload.node->body.empty() || attributes->node->empty() || renderFormat == UndefinedRenderFormat) {
+            return body;
+        }
+
+        // Expand MSON into Refract
+        refract::IElement* element = MSONToRefract(*attributes, context);
+
+        if (!element) {
+            return body;
+        }
+
+        refract::IElement* expanded = ExpandRefract(element, context);
+
+        if (!expanded) {
+            return body;
+        }
+
+        // One of this will always execute since we have a catch above for not having render format
+        switch (renderFormat) {
+            case JSONRenderFormat:
+            {
+                refract::RenderJSONVisitor renderer;
+                refract::Visit(renderer, *expanded);
+
+                delete expanded;
+
+                return std::make_pair(renderer.getString(), NodeInfo<Asset>::NullSourceMap());
+            }
+
+            case JSONSchemaRenderFormat:
+            {
+                refract::JSONSchemaVisitor renderer;
+                std::string result = renderer.getSchema(*expanded);
+
+                delete expanded;
+
+                return std::make_pair(result, NodeInfo<Asset>::NullSourceMap());
+            }
+
+            case UndefinedRenderFormat:
+                break;
+        }
+
+        // Throw exception
+        throw snowcrash::Error("unknown content type for messageBody to be rendered", snowcrash::ApplicationError);
+    }
+
+    NodeInfoByValue<Asset> renderPayloadSchema(const NodeInfo<snowcrash::Payload>& payload,
+                                               const NodeInfo<snowcrash::Action>& action,
+                                               ConversionContext& context) {
+
+        NodeInfoByValue<Asset> schema = std::make_pair(payload.node->schema, &payload.sourceMap->schema);
+
+        NodeInfo<Attributes> payloadAttributes = MAKE_NODE_INFO(payload, attributes);
+        NodeInfo<Attributes> actionAttributes = MAKE_NODE_INFO(action, attributes);
+
+        // hold attributes via pointer - because problems with assignment in NodeInfo<>
+        NodeInfo<Attributes>* attributes = &payloadAttributes;
+
+        if (payload.node->attributes.empty() && !action.isNull() && !action.node->attributes.empty()) {
+            attributes = &actionAttributes;
+        }
+
+        // Generate Schema only if Body content type is JSON
+        if (!payload.node->schema.empty() || payload.node->attributes.empty() ||
+            findRenderFormat(getContentTypeFromHeaders(payload.node->headers)) != JSONRenderFormat) {
+
+            return schema;
+        }
+
+        refract::JSONSchemaVisitor renderer;
+        refract::IElement* element = MSONToRefract(*attributes, context);
+
+        if (!element) {
+            return schema;
+        }
+
+        refract::IElement* expanded = ExpandRefract(element, context);
+
+        if (!expanded) {
+            return schema;
+        }
+
+        std::string result = renderer.getSchema(*expanded);
+        delete expanded;
+
+        return std::make_pair(result, NodeInfo<Asset>::NullSourceMap());
+    }
+}

data/ext/drafter/src/Render.h

@@ -0,0 +1,40 @@
+//
+//  Render.h
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef DRAFTER_RENDER_H
+#define DRAFTER_RENDER_H
+
+#include "Serialize.h"
+
+namespace drafter {
+
+    const char* const JSONSchemaContentType = "application/schema+json";
+    const char* const JSONRegex = "^[[:blank:]]*application/(.*\\+)?json[[:blank:]]*(;.*|$)";
+    const char* const JSONSchemaRegex = "^[[:blank:]]*application/schema\\+json[[:blank:]]*(;.*|$)";
+
+    enum RenderFormat {
+        UndefinedRenderFormat = 0,   // Undefined format
+        JSONRenderFormat = 1,        // JSON format
+        JSONSchemaRenderFormat = 2   // JSON Schema format
+    };
+
+    class ConversionContext;
+
+    RenderFormat findRenderFormat(const std::string& contentType);
+    std::string getContentTypeFromHeaders(const snowcrash::Headers& headers);
+
+    NodeInfoByValue<snowcrash::Asset> renderPayloadBody(const NodeInfo<snowcrash::Payload>& payload,
+                                                        const NodeInfo<snowcrash::Action>& action,
+                                                        ConversionContext& context);
+
+    NodeInfoByValue<snowcrash::Asset> renderPayloadSchema(const NodeInfo<snowcrash::Payload>& payload,
+                                                          const NodeInfo<snowcrash::Action>& action,
+                                                          ConversionContext& context);
+}
+
+#endif

data/ext/drafter/src/Serialize.cc

@@ -0,0 +1,160 @@
+//
+//  Serialize.cc
+//  drafter
+//
+//  Created by Zdenek Nemec on 5/3/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#include "Serialize.h"
+#include "StringUtility.h"
+
+#include <cstdlib>
+
+using namespace drafter;
+
+namespace drafter {
+
+    refract::ArrayElement* CreateArrayElement(refract::IElement* value, bool rFull)
+    {
+        refract::ArrayElement* array = new refract::ArrayElement;
+
+        if (rFull) {
+            value->renderType(refract::IElement::rFull);
+        }
+
+        array->push_back(value);
+        return array;
+    }
+}
+
+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::DataStructure = "dataStructure";
+const std::string SerializeKey::DataStructures = "dataStructures";
+const std::string SerializeKey::ResourceGroup = "resourceGroup";
+const std::string SerializeKey::ResourceGroups = "resourceGroups";
+const std::string SerializeKey::Resource = "resource";
+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";
+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::Nullable = "nullable";
+const std::string SerializeKey::Example = "example";
+const std::string SerializeKey::Values = "values";
+
+const std::string SerializeKey::Source = "source";
+const std::string SerializeKey::Resolved = "resolved";
+
+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::Warning = "warning";
+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";
+
+const std::string SerializeKey::Variable = "variable";
+const std::string SerializeKey::Content = "content";
+const std::string SerializeKey::Meta = "meta";
+const std::string SerializeKey::Title = "title";
+const std::string SerializeKey::Classes = "classes";
+const std::string SerializeKey::Samples = "samples";
+const std::string SerializeKey::TypeAttributes = "typeAttributes";
+const std::string SerializeKey::Optional = "optional";
+const std::string SerializeKey::Fixed = "fixed";
+const std::string SerializeKey::FixedType = "fixedType";
+const std::string SerializeKey::True = "true";
+const std::string SerializeKey::Generic = "generic";
+const std::string SerializeKey::Enum = "enum";
+const std::string SerializeKey::Ref = "ref";
+const std::string SerializeKey::Href = "href";
+const std::string SerializeKey::Path = "path";
+
+const std::string SerializeKey::Category = "category";
+const std::string SerializeKey::Copy = "copy";
+const std::string SerializeKey::API = "api";
+const std::string SerializeKey::User = "user";
+const std::string SerializeKey::Transition = "transition";
+const std::string SerializeKey::HrefVariables = "hrefVariables";
+const std::string SerializeKey::HTTPHeaders = "httpHeaders";
+const std::string SerializeKey::HTTPTransaction = "httpTransaction";
+const std::string SerializeKey::ContentType = "contentType";
+const std::string SerializeKey::HTTPResponse = "httpResponse";
+const std::string SerializeKey::HTTPRequest = "httpRequest";
+const std::string SerializeKey::StatusCode = "statusCode";
+const std::string SerializeKey::Asset = "asset";
+const std::string SerializeKey::MessageBody = "messageBody";
+const std::string SerializeKey::MessageBodySchema = "messageBodySchema";
+const std::string SerializeKey::Data = "data";
+
+const std::string SerializeKey::ParseResult = "parseResult";
+const std::string SerializeKey::Annotation = "annotation";
+const std::string SerializeKey::SourceMap = "sourceMap";
+
+
+namespace drafter {
+
+    template <>
+    std::pair<bool, bool> LiteralTo<bool>(const mson::Literal& literal)
+    {
+        bool valid = false;
+        if (literal == "true" || literal == "false") {
+            valid = true;
+        }
+        return std::make_pair(valid, literal == SerializeKey::True);
+    }
+
+    template <>
+    std::pair<bool, double> LiteralTo<double>(const mson::Literal& literal)
+    {
+        char* pos = 0;
+        bool valid = false;
+        double value = 0;
+
+        value = std::strtod(literal.c_str(), &pos);
+        const char* end = literal.c_str() + literal.length();
+        if (pos == end) {
+            valid = true;
+        }
+        else {
+            // check for trailing whitespaces
+            valid = (literal.end() != std::find_if(literal.begin() + (end-pos), literal.end(), ::isspace));
+        }
+
+        return std::make_pair(valid, value);
+    }
+
+    template <>
+    std::pair<bool, std::string> LiteralTo<std::string>(const mson::Literal& literal)
+    {
+        return std::make_pair(!literal.empty(), literal);
+    }
+};