lounge_lizard 0.1.0

data/ext/drafter/src/refract/SerializeVisitor.cc

@@ -0,0 +1,214 @@
+//
+//  refract/SerializeVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 18/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+
+#include "SerializeCompactVisitor.h"
+#include "SerializeVisitor.h"
+#include "TypeQueryVisitor.h"
+
+namespace refract
+{
+
+    namespace
+    {
+        sos::Object SerializeElementCollection(const IElement::MemberElementCollection& collection, bool generateSourceMap)
+        {
+            typedef IElement::MemberElementCollection::const_iterator iterator;
+
+            sos::Object result;
+
+            for (iterator it = collection.begin(); it != collection.end(); ++it) {
+
+                if (!generateSourceMap) {
+                    StringElement* str = TypeQueryVisitor::as<StringElement>((*it)->value.first);
+                    if (str && str->value == "sourceMap"){
+                        continue;
+                    }
+                }
+
+                SosSerializeCompactVisitor s(generateSourceMap);
+                Visit(s, *(*it));
+                result.set(s.key(), s.value());
+            }
+
+            return result;
+        }
+
+        sos::Object ElementToObject(const IElement* e, bool generateSourceMap)
+        {
+            SosSerializeVisitor s(generateSourceMap);
+            Visit(s, *e);
+            return s.get();
+        }
+
+        template <typename T>
+        sos::Array SerializeValueList(const T& e, bool generateSourceMap) {
+            sos::Array array;
+            typedef typename T::ValueType::const_iterator iterator;
+
+            for (iterator it = e.value.begin(); it != e.value.end(); ++it) {
+                array.push(ElementToObject(*it, generateSourceMap));
+            }
+
+            return array;
+        }
+
+        IElement::renderFlags SelectSerializationType(const IElement& e, bool generateSourceMap) {
+
+            if (generateSourceMap) {
+                IElement::MemberElementCollection::const_iterator it = e.attributes.find("sourceMap");
+                // there is sourceMap in attributes
+                if (it != e.attributes.end()) {
+                    return IElement::rFull;
+                }
+            }
+
+            if (e.renderType() == IElement::rCompact || e.renderType() == IElement::rCompactContent) {
+                return IElement::rCompact;
+            }
+
+            return IElement::rFull;
+        }
+
+    } // end of anonymous namespace
+
+    void SosSerializeVisitor::operator()(const IElement& e)
+    {
+        result.set("element", sos::String(e.element()));
+        bool sourceMap = generateSourceMap;
+
+        sos::Object meta = SerializeElementCollection(e.meta, sourceMap);
+        if (!meta.empty()) {
+            result.set("meta", meta);
+        }
+
+        if (e.element() == "annotation") {
+            sourceMap = true;
+        }
+        sos::Object attr = SerializeElementCollection(e.attributes, sourceMap);
+        if (!attr.empty()) {
+            result.set("attributes", attr);
+        }
+
+        if (e.empty())
+            return;
+
+        const IElement::renderFlags render = SelectSerializationType(e, generateSourceMap);
+
+        if (render == IElement::rCompact) {
+            SosSerializeCompactVisitor s(generateSourceMap);
+            VisitBy(e, s);
+            result.set("content", s.value());
+        } else {
+            VisitBy(e, *this);
+            result.set("content", partial);
+        }
+    }
+
+    void SosSerializeVisitor::SetSerializerValue(SosSerializeVisitor& s, sos::Base& value)
+    {
+        if (!s.key.empty()) {
+            s.result.set(s.key, value);
+            s.key.clear();
+        } else {
+            s.partial = value;
+        }
+    }
+
+    void SosSerializeVisitor::operator()(const NullElement& e)
+    {
+        sos::Base value = sos::Null();
+        SetSerializerValue(*this, value);
+    }
+
+    void SosSerializeVisitor::operator()(const StringElement& e)
+    {
+        sos::Base value = sos::Null();
+
+        if (!e.empty()) {
+            value = sos::String(e.value);
+        }
+
+        SetSerializerValue(*this, value);
+    }
+
+    void SosSerializeVisitor::operator()(const NumberElement& e)
+    {
+        sos::Base value = sos::Null();
+
+        if (!e.empty()) {
+            value = sos::Number(e.value);
+        }
+
+        SetSerializerValue(*this, value);
+    }
+
+    void SosSerializeVisitor::operator()(const BooleanElement& e)
+    {
+        sos::Base value = sos::Null();
+
+        if (!e.empty()) {
+            value = sos::Boolean(e.value);
+        }
+
+        SetSerializerValue(*this, value);
+    }
+
+
+    void SosSerializeVisitor::operator()(const MemberElement& e)
+    {
+        sos::Object object;
+
+        if (e.value.first) {
+            object.set("key", ElementToObject(e.value.first, generateSourceMap));
+        }
+
+        if (e.value.second) {
+            object.set("value", ElementToObject(e.value.second, generateSourceMap));
+        }
+
+        SetSerializerValue(*this, object);
+    }
+
+    void SosSerializeVisitor::operator()(const ArrayElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+    void SosSerializeVisitor::operator()(const EnumElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+    void SosSerializeVisitor::operator()(const ObjectElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+    void SosSerializeVisitor::operator()(const ExtendElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+    void SosSerializeVisitor::operator()(const OptionElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+    void SosSerializeVisitor::operator()(const SelectElement& e)
+    {
+        sos::Array array = SerializeValueList(e, generateSourceMap);
+        SetSerializerValue(*this, array);
+    }
+
+}; // namespace refract

data/ext/drafter/src/refract/SerializeVisitor.h

@@ -0,0 +1,55 @@
+//
+//  refract/SerializeVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_SERIALIZEVISITOR_H
+#define REFRACT_SERIALIZEVISITOR_H
+
+#include "sos.h"
+#include <string>
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    class SosSerializeVisitor
+    {
+
+        sos::Object result;
+        sos::Base partial;
+        std::string key;
+        bool generateSourceMap;
+
+
+        static void SetSerializerValue(SosSerializeVisitor& s, sos::Base& value);
+
+     public:
+
+        SosSerializeVisitor(bool generateSourceMap) : partial(sos::Null()), generateSourceMap(generateSourceMap) {}
+
+        void operator()(const IElement& e);
+        void operator()(const NullElement& e);
+        void operator()(const StringElement& e);
+        void operator()(const NumberElement& e);
+        void operator()(const BooleanElement& e);
+        void operator()(const ArrayElement& e);
+        void operator()(const EnumElement& e);
+        void operator()(const MemberElement& e);
+        void operator()(const ObjectElement& e);
+        void operator()(const ExtendElement& e);
+        void operator()(const SelectElement& e);
+        void operator()(const OptionElement& e);
+
+        sos::Object get()
+        {
+            return result;
+        }
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_SERIALIZEVISITOR_H

data/ext/drafter/src/refract/TypeQueryVisitor.cc

@@ -0,0 +1,46 @@
+//
+//  refract/TypeQueryVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+#include "TypeQueryVisitor.h"
+
+
+#define VISIT_IMPL( ELEMENT ) void TypeQueryVisitor::operator()(const ELEMENT ## Element& e) { typeInfo = ELEMENT; }
+
+namespace refract
+{
+    TypeQueryVisitor::TypeQueryVisitor() : typeInfo(Unknown)
+    {
+    }
+
+    void TypeQueryVisitor::operator()(const IElement& e)
+    {
+        TypeQueryVisitor query;
+        VisitBy(e, query);
+        typeInfo = query.get();
+    }
+
+
+    VISIT_IMPL(Null)
+    VISIT_IMPL(String)
+    VISIT_IMPL(Number)
+    VISIT_IMPL(Boolean)
+    VISIT_IMPL(Array)
+    VISIT_IMPL(Enum)
+    VISIT_IMPL(Member)
+    VISIT_IMPL(Object)
+    VISIT_IMPL(Extend)
+    VISIT_IMPL(Option)
+    VISIT_IMPL(Select)
+
+    TypeQueryVisitor::ElementType TypeQueryVisitor::get() const {
+        return typeInfo;
+    }
+
+}; // namespace refract
+
+#undef VISIT_IMPL

data/ext/drafter/src/refract/TypeQueryVisitor.h

@@ -0,0 +1,110 @@
+//
+//  refract/TypeQueryVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_TYPEQUERYVISITOR_H
+#define REFRACT_TYPEQUERYVISITOR_H
+
+#include "ElementFwd.h"
+#include "Visitor.h"
+
+namespace refract
+{
+
+    class TypeQueryVisitor 
+    {
+
+    public:
+        typedef enum
+        {
+            Null,
+
+            String,
+            Number,
+            Boolean,
+
+            Array,
+            Member,
+            Object,
+            Enum,
+
+            Extend,
+
+            Option,
+            Select,
+
+            Unknown = 0,
+        } ElementType;
+
+    private:
+        ElementType typeInfo;
+
+    public:
+
+        TypeQueryVisitor();
+
+        void operator()(const IElement& e);
+        void operator()(const NullElement& e);
+        void operator()(const StringElement& e);
+        void operator()(const NumberElement& e);
+        void operator()(const BooleanElement& e);
+        void operator()(const ArrayElement& e);
+        void operator()(const MemberElement& e);
+        void operator()(const ObjectElement& e);
+        void operator()(const EnumElement& e);
+        void operator()(const ExtendElement& e);
+        void operator()(const OptionElement& e);
+        void operator()(const SelectElement& e);
+
+        ElementType get() const;
+
+        template<typename E>
+        static E* as(IElement* e)
+        {
+            if (!e) {
+                return static_cast<E*>(e);
+            }
+
+            TypeQueryVisitor tq;
+            Visit(tq, *e);
+
+            E type;
+            TypeQueryVisitor eq;
+            VisitBy(type, eq);
+
+            if (eq.typeInfo != tq.typeInfo) {
+                return 0;
+            }
+
+            return static_cast<E*>(e);
+        }
+
+        template<typename E>
+        static const E* as(const IElement* e)
+        {
+            if (!e) {
+                return static_cast<const E*>(e);
+            }
+
+            TypeQueryVisitor tq;
+            Visit(tq, *e);
+
+            E type;
+            TypeQueryVisitor eq;
+            VisitBy(type, eq);
+
+            if (eq.typeInfo != tq.typeInfo) {
+                return 0;
+            }
+
+            return static_cast<const E*>(e);
+        }
+
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_TYPEQUERYVISITOR_H

data/ext/drafter/src/refract/Visitor.h

@@ -0,0 +1,126 @@
+//
+//  refract/Visitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_VISITOR_H
+#define REFRACT_VISITOR_H
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    struct IApply {
+        virtual void visit(const IElement& e) = 0;
+
+        virtual void visit(const NullElement& e) = 0;
+        virtual void visit(const StringElement& e) = 0;
+        virtual void visit(const NumberElement& e) = 0;
+        virtual void visit(const BooleanElement& e) = 0;
+        virtual void visit(const ArrayElement& e) = 0;
+        virtual void visit(const EnumElement& e) = 0;
+        virtual void visit(const MemberElement& e) = 0;
+        virtual void visit(const ObjectElement& e) = 0;
+        virtual void visit(const ExtendElement& e) = 0;
+        virtual void visit(const OptionElement& e) = 0;
+        virtual void visit(const SelectElement& e) = 0;
+
+        virtual ~IApply() {}
+    };
+
+    template <typename Impl>
+    struct ApplyImpl : public IApply {
+
+        Impl& impl;
+        ApplyImpl(Impl& impl) : impl(impl) {}
+
+        virtual void visit(const IElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const NullElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const StringElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const NumberElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const BooleanElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const ArrayElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const EnumElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const MemberElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const ObjectElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const ExtendElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const OptionElement& e) {
+            impl(e);
+        }
+
+        virtual void visit(const SelectElement& e) {
+            impl(e);
+        }
+
+        virtual ~ApplyImpl() {}
+    };
+
+    class Visitor {
+
+    private:
+
+        IApply* apply;
+
+    public:
+
+        template <typename Functor>
+        Visitor(Functor& functor) : apply(new ApplyImpl<Functor>(functor)) {}
+        virtual ~Visitor() {
+            delete apply;
+        }
+
+        template<typename T>
+        void visit(const T& e) {
+            apply->visit(e);
+        }
+
+    };
+
+    template <typename Element, typename Functor>
+    void Visit(Functor& functor, const Element& element) {
+        Visitor visitor(functor);
+        visitor.visit(element);
+    }
+
+    template <typename Element, typename Functor>
+    void VisitBy(const Element& element, Functor& functor) {
+        Visitor visitor(functor);
+        element.content(visitor);
+    }
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_VISITOR_H

data/ext/drafter/src/refract/VisitorUtils.cc

@@ -0,0 +1,63 @@
+//
+//  refract/VisitorUtils.cc
+//  librefract
+//
+//  Created by Vilibald Wanča on 09/11/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+#include "VisitorUtils.h"
+
+namespace refract
+{
+
+    StringElement* GetDescription(const IElement& e)
+    {
+        IElement::MemberElementCollection::const_iterator i = e.meta.find("description");
+
+        if (i == e.meta.end()) {
+            return NULL;
+        }
+
+        return TypeQueryVisitor::as<StringElement>((*i)->value.second);
+    }
+
+    void SetRenderFlag(RefractElements& elements, const IElement::renderFlags flag) {
+        std::for_each(elements.begin(), elements.end(),
+                 std::bind(static_cast<void (refract::IElement::*)(const refract::IElement::renderFlags)>(&refract::IElement::renderType), std::placeholders::_1, flag));
+    }
+
+    std::string GetKeyAsString(const MemberElement& e)
+    {
+
+        IElement* element = e.value.first;
+
+        if (StringElement* str = TypeQueryVisitor::as<StringElement>(element)) {
+            return str->value;
+        }
+
+        if (ExtendElement* ext = TypeQueryVisitor::as<ExtendElement>(element)) {
+            IElement* merged = ext->merge();
+
+            if (StringElement* str = TypeQueryVisitor::as<StringElement>(merged)) {
+
+                std::string key = str->value;
+                if (key.empty()) {
+                    const std::string* k = GetValue<StringElement>(*str);
+                    if (k) {
+                        key = *k;
+                    }
+                }
+                delete merged;
+
+                return key;
+
+            }
+
+            delete merged;
+        }
+
+        return std::string();
+    }
+
+}