lounge_lizard 0.1.0

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

@@ -0,0 +1,255 @@
+//
+//  refract/RenderJSONVisitor.cc
+//  librefract
+//
+//  Created by Pavan Kumar Sunkara on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "VisitorUtils.h"
+#include "sosJSON.h"
+#include <sstream>
+#include "SerializeCompactVisitor.h"
+
+#include "RenderJSONVisitor.h"
+
+namespace refract
+{
+
+    namespace {
+
+        IElement* getEnumValue(const ExtendElement& extend)
+        {
+            if (extend.empty()) {
+                return NULL;
+            }
+
+            for (ExtendElement::ValueType::const_reverse_iterator it = extend.value.rbegin();
+                 it != extend.value.rend();
+                 ++it) {
+
+                const EnumElement* element = TypeQueryVisitor::as<EnumElement>(*it);
+
+                if (!element) {
+                    continue;
+                }
+
+                const ArrayElement::ValueType* items = GetValue<EnumElement>(*element);
+
+                if (!items->empty()) {
+                    return *items->begin();
+                }
+            }
+
+            return NULL;
+        }
+
+        template <typename T>
+        void FetchMembers(const T& element, typename T::ValueType& members)
+        {
+            const typename T::ValueType* val = GetValue<T>(element);
+
+            if (!val) {
+                return;
+            }
+
+            for (typename T::ValueType::const_iterator it = val->begin();
+                 it != val->end();
+                 ++it) {
+
+                if (!(*it) || (*it)->empty()) {
+                    continue;
+                }
+
+                if ((*it)->element() == "ref") {
+                    HandleRefWhenFetchingMembers<T>(*it, members, FetchMembers<T>);
+                    continue;
+                }
+                else if (SelectElement* select = TypeQueryVisitor::as<SelectElement>(*it)) {
+                    if (select->value.empty() || !(*select->value.begin())) {
+                        continue;
+                    }
+
+                    FetchMembers(*(*select->value.begin()), members);
+                    continue;
+                }
+
+                RenderJSONVisitor renderer;
+                Visit(renderer, *(*it));
+                IElement* e = renderer.getOwnership();
+
+                if (!e) {
+                    continue;
+                }
+
+                e->renderType(IElement::rCompact);
+                members.push_back(e);
+
+            }
+        }
+
+    }
+
+    RenderJSONVisitor::RenderJSONVisitor() : result(NULL), enumValue(NULL) {}
+
+    RenderJSONVisitor::~RenderJSONVisitor() {
+        if (result) {
+            delete result;
+        }
+
+        if (enumValue) {
+            delete enumValue;
+        }
+    }
+
+    void RenderJSONVisitor::operator()(const IElement& e) {
+        VisitBy(e, *this);
+    }
+
+    void RenderJSONVisitor::operator()(const MemberElement& e) {
+
+        std::string key = GetKeyAsString(e);
+
+        if (key.empty()) {
+            return;
+        }
+
+        RenderJSONVisitor renderer;
+
+        if (e.value.second) {
+            if (IsTypeAttribute(e, "nullable") && e.value.second->empty()) {
+                renderer.result = new NullElement;
+            }
+            else if (IsTypeAttribute(e, "optional") && e.value.second->empty()) {
+                return;
+            }
+            else {
+                Visit(renderer, *e.value.second);
+                if (!renderer.result) {
+                    return;
+                }
+            }
+        }
+
+        result = new MemberElement(key,
+                                   renderer.result ? renderer.getOwnership() : new StringElement,
+                                   IElement::rCompact);
+    }
+
+    void RenderJSONVisitor::operator()(const ObjectElement& e) {
+        ObjectElement::ValueType members;
+        FetchMembers(e, members);
+        ObjectElement* o = new ObjectElement;
+        o->set(members);
+        o->renderType(IElement::rCompact);
+        result = o;
+    }
+
+    void RenderJSONVisitor::operator()(const EnumElement& e) {
+
+        if (!enumValue) { // there is no enumValue injected from ExtendElement,try to pick value directly
+
+            const EnumElement::ValueType* val = GetEnumValue(e);
+            if (val && !val->empty()) {
+                enumValue = val->front()->clone();
+            }
+            else {
+                enumValue = new StringElement;
+            }
+        }
+
+        RenderJSONVisitor renderer;
+        VisitBy(*enumValue, renderer);
+        result = renderer.getOwnership();
+
+        delete enumValue;
+        enumValue = NULL;
+
+    }
+
+    void RenderJSONVisitor::operator()(const ArrayElement& e) {
+        ArrayElement::ValueType members;
+        FetchMembers(e, members);
+        ArrayElement* a = new ArrayElement;
+        a->set(members);
+        a->renderType(IElement::rCompact);
+        result = a;
+    }
+
+    void RenderJSONVisitor::operator()(const NullElement& e) {
+        result = new NullElement;
+    }
+
+    template <typename T>
+    IElement* getResult(const T& e)
+    {
+        const typename T::ValueType* v = GetValue<T>(e);
+
+        if (!v) {
+            return NULL;
+        }
+
+        T* result = IElement::Create(*v);
+        result->renderType(IElement::rCompact);
+
+        return result;
+    }
+
+    void RenderJSONVisitor::operator()(const StringElement& e) {
+        result = getResult(e);
+    }
+
+    void RenderJSONVisitor::operator()(const NumberElement& e) {
+        result = getResult(e);
+    }
+
+    void RenderJSONVisitor::operator()(const BooleanElement& e) {
+        result = getResult(e);
+    }
+
+    void RenderJSONVisitor::operator()(const ExtendElement& e) {
+
+        RenderJSONVisitor renderer;
+        IElement* merged = e.merge();
+
+        if (!merged) {
+            return;
+        }
+
+        if (TypeQueryVisitor::as<EnumElement>(merged)) {
+            renderer.enumValue = getEnumValue(e);
+            if (renderer.enumValue) {
+                renderer.enumValue = renderer.enumValue->clone();
+            }
+        }
+
+        Visit(renderer, *merged);
+        result = renderer.getOwnership();
+
+        delete merged;
+    }
+
+   IElement* RenderJSONVisitor::getOwnership() {
+       IElement* ret = result;
+       result = NULL;
+       return ret;
+   }
+
+    std::string RenderJSONVisitor::getString() const {
+        std::string out;
+
+        if (result) {
+            sos::SerializeJSON serializer;
+            std::stringstream ss;
+
+            // FIXME: remove SosSerializeCompactVisitor dependency
+            SosSerializeCompactVisitor s;
+            VisitBy(*result, s);
+            serializer.process(s.value(), ss);
+
+            return ss.str();
+        }
+
+        return out;
+    }
+}

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

@@ -0,0 +1,51 @@
+//
+//  refract/RenderJSONVisitor.h
+//  librefract
+//
+//  Created by Pavan Kumar Sunkara on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef REFRACT_RENDERJSONVISITOR_H
+#define REFRACT_RENDERJSONVISITOR_H
+
+#include "sos.h"
+#include <string>
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    class RenderJSONVisitor
+    {
+        IElement* result;
+        IElement* enumValue;
+    public:
+
+        RenderJSONVisitor();
+        virtual ~RenderJSONVisitor();
+
+        void operator()(const IElement& e);
+        void operator()(const MemberElement& e);
+        void operator()(const ObjectElement& e);
+        void operator()(const ArrayElement& e);
+        void operator()(const EnumElement& e);
+
+        void operator()(const NullElement& e);
+        void operator()(const StringElement& e);
+        void operator()(const NumberElement& e);
+        void operator()(const BooleanElement& e);
+        void operator()(const ExtendElement& e);
+
+        // FIXME: throwning - not implemented 
+        // need to resolve in ApplyVisitor
+        //void operator()(const OptionElement& e);
+        //void operator()(const SelectElement& e);
+
+        std::string getString() const;
+        IElement* getOwnership(); 
+    };
+}
+
+#endif

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

@@ -0,0 +1,167 @@
+//
+//  refract/SerializeCompactVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+
+#include "SerializeVisitor.h"
+#include "SerializeCompactVisitor.h"
+
+namespace refract
+{
+
+    struct IsFullRender {
+        typedef const IElement* first_argument_type;
+        typedef const bool second_argument_type;
+        typedef const bool result_type;
+
+        bool operator()(const IElement* element, const bool generateSourceMap) const {
+
+            if (generateSourceMap) {
+                IElement::MemberElementCollection::const_iterator it = element->attributes.find("sourceMap");
+                // there is sourceMap in attributes
+                if (it != element->attributes.end()) {
+                    return true;
+                }
+            }
+
+            return element && (element->renderType() == IElement::rFull || element->renderType() == IElement::rCompactContent);
+        }
+    };
+
+    void SosSerializeCompactVisitor::operator()(const IElement& e)
+    {
+        throw NotImplemented("NI: IElement Compact Serialization");
+    }
+
+    void SosSerializeCompactVisitor::operator()(const NullElement& e)
+    {
+        value_ = sos::Null();
+    }
+
+    void SosSerializeCompactVisitor::operator()(const StringElement& e)
+    {
+        value_ = sos::String(e.value);
+    }
+
+    void SosSerializeCompactVisitor::operator()(const NumberElement& e)
+    {
+        value_ = sos::Number(e.value);
+    }
+
+    void SosSerializeCompactVisitor::operator()(const BooleanElement& e)
+    {
+        value_ = sos::Boolean(e.value);
+    }
+
+    namespace {
+
+        template <typename Values>
+        void SerializeValues(sos::Array& array, const Values& values, bool generateSourceMap)
+        {
+
+            for (typename Values::const_iterator it = values.begin(); it != values.end(); ++it) {
+                if (IsFullRender()((*it), generateSourceMap)) {
+                    SosSerializeVisitor s(generateSourceMap);
+                    Visit(s, *(*it));
+                    array.push(s.get());
+                }
+                else {
+                    SosSerializeCompactVisitor s(generateSourceMap);
+                    VisitBy(*(*it), s);
+                    array.push(s.value());
+                }
+            }
+        }
+    }
+
+    void SosSerializeCompactVisitor::operator()(const EnumElement& e)
+    {
+        sos::Array array;
+        SerializeValues(array, e.value, generateSourceMap);
+        value_ = array;
+    }
+
+    void SosSerializeCompactVisitor::operator()(const ArrayElement& e)
+    {
+        sos::Array array;
+        SerializeValues(array, e.value, generateSourceMap);
+        value_ = array;
+    }
+
+    void SosSerializeCompactVisitor::operator()(const MemberElement& e)
+    {
+        if (e.value.first) {
+            SosSerializeCompactVisitor s(generateSourceMap);
+            VisitBy(*e.value.first, s);
+            key_ = s.value().str;
+        }
+
+        if (e.value.second) {
+            if (!IsFullRender()(e.value.second, generateSourceMap)) {
+                VisitBy(*e.value.second, *this);
+            }
+            else { // value has request to be serialized in Expanded form
+                SosSerializeVisitor s(generateSourceMap);
+                Visit(s, *e.value.second);
+                value_ = s.get();
+            }
+        }
+    }
+
+    void SosSerializeCompactVisitor::operator()(const ObjectElement& e)
+    {
+
+        typedef ObjectElement::ValueType::const_iterator iterator;
+        iterator it = find_if(e.value.begin(), e.value.end(), std::bind(IsFullRender(), std::placeholders::_1, generateSourceMap));
+
+        // if there is ANY element required to be serialized in Full
+        // we must use array to serialize
+        if (it != e.value.end()) {
+            sos::Array arr;
+
+            for (iterator it = e.value.begin(); it != e.value.end(); ++it) {
+                SosSerializeVisitor s(generateSourceMap);
+                Visit(s, *(*it));
+                arr.push(s.get());
+            }
+
+            value_ = arr;
+        }
+        else {
+            sos::Object obj;
+
+            for (iterator it = e.value.begin(); it != e.value.end(); ++it) {
+                SosSerializeCompactVisitor sv(generateSourceMap);
+                VisitBy(*(*it), sv);
+                obj.set(sv.key(), sv.value());
+            }
+
+            value_ = obj;
+        }
+    }
+
+    void SosSerializeCompactVisitor::operator()(const ExtendElement& e)
+    {
+        throw NotImplemented("ExtendElement serialization Not Implemented");
+    }
+
+    void SosSerializeCompactVisitor::operator()(const OptionElement& e)
+    {
+        sos::Array array;
+        SerializeValues(array, e.value, generateSourceMap);
+        value_ = array;
+    }
+
+    void SosSerializeCompactVisitor::operator()(const SelectElement& e)
+    {
+        sos::Array array;
+        SerializeValues(array, e.value, generateSourceMap);
+        value_ = array;
+    }
+
+
+}; // namespace refract

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

@@ -0,0 +1,56 @@
+//
+//  refract/SerializeCompactVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_SERIALIZECOMPACTVISITOR_H
+#define REFRACT_SERIALIZECOMPACTVISITOR_H
+
+#include "sos.h"
+#include <string>
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    class SosSerializeCompactVisitor 
+    {
+        std::string key_;
+        sos::Base value_;
+        bool generateSourceMap;
+
+    public:
+        SosSerializeCompactVisitor() : generateSourceMap(true) {}
+        SosSerializeCompactVisitor(bool generateSourceMap) : 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);
+
+        std::string key()
+        {
+            return key_;
+        }
+
+        sos::Base value()
+        {
+            return value_;
+        }
+
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_SERIALIZECOMPACTVISITOR_H