lounge_lizard 0.1.0

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

@@ -0,0 +1,59 @@
+//
+//  refract/ElementInserter.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_ELEMENTINSERTER_H
+#define REFRACT_ELEMENTINSERTER_H
+
+#include <iterator>
+
+namespace refract
+{
+
+    // Forward declarations of Elements
+    struct IElement;
+
+    template <typename T>
+    struct ElementInsertIterator : public std::iterator<std::output_iterator_tag, void, void, void, void> {
+        T& element;
+
+        ElementInsertIterator(T& element) : element(element) {}
+
+        ElementInsertIterator(const ElementInsertIterator& other) : element(other.element) {}
+
+        ElementInsertIterator& operator=(const ElementInsertIterator& other) {
+            element = other.element;
+            return *this;
+        }
+
+        ElementInsertIterator& operator=(refract::IElement* e) {
+            element.push_back(e);
+            return *this;
+        }
+
+        ElementInsertIterator& operator=(const refract::IElement* e) {
+            element.push_back(e);
+            return *this;
+        }
+
+        ElementInsertIterator& operator++() {
+            return *this;
+        }
+
+        ElementInsertIterator& operator*() {
+            return *this;
+        }
+        
+    };
+
+    template <typename T>
+    ElementInsertIterator<T> ElementInserter(T& element) {
+        return ElementInsertIterator<T>(element);
+    }
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_ELEMENTINSERTER_H

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

@@ -0,0 +1,31 @@
+//
+//  refract/Exception.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_EXCEPTION_H
+#define REFRACT_EXCEPTION_H
+
+#include <stdexcept>
+
+namespace refract
+{
+
+    struct LogicError : std::logic_error {
+        explicit LogicError(const std::string& msg) : std::logic_error(msg) {}
+    };
+
+    // will be removed in future
+    struct NotImplemented : std::runtime_error {
+        explicit NotImplemented(const std::string& msg) : std::runtime_error(msg) {}
+    };
+
+    struct Deprecated : std::logic_error {
+        explicit Deprecated(const std::string& msg) : std::logic_error(msg) {}
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_EXCEPTION_H

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

@@ -0,0 +1,359 @@
+//
+//  refract/ExpandVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "Element.h"
+#include "Registry.h"
+#include <stack>
+
+#include <functional>
+
+#include <sstream>
+
+#include"SourceAnnotation.h"
+
+#include "IsExpandableVisitor.h"
+#include "ExpandVisitor.h"
+#include "TypeQueryVisitor.h"
+#include "VisitorUtils.h"
+
+#define VISIT_IMPL( ELEMENT ) void ExpandVisitor::operator()(const ELEMENT ## Element& e) { result = Expand(e, context); }
+
+namespace refract
+{
+
+    namespace
+    {
+
+        bool Expandable(const IElement& e)
+        {
+            IsExpandableVisitor v;
+            VisitBy(e, v);
+            return v.get();
+        }
+
+        void CopyMetaId(IElement& dst, const IElement& src)
+        {
+            IElement::MemberElementCollection::const_iterator name = src.meta.find("id");
+            if (name != src.meta.end() && (*name)->value.second && !(*name)->value.second->empty()) {
+                dst.meta["id"] = (*name)->value.second->clone();
+            }
+        }
+
+        void MetaIdToRef(IElement& e)
+        {
+            IElement::MemberElementCollection::const_iterator name = e.meta.find("id");
+            if (name != e.meta.end() && (*name)->value.second && !(*name)->value.second->empty()) {
+                IElement* clone = (*name)->value.second->clone();
+                e.meta["ref"] = clone;
+                e.meta.erase("id");
+            }
+        }
+
+        template <typename T>
+        struct ExpandValueImpl {
+
+            template <typename Functor>
+            T operator()(const T& value, Functor&) {
+                return value;
+            }
+        };
+
+        template <>
+        struct ExpandValueImpl<RefractElements> {
+
+            template <typename Functor>
+            RefractElements operator()(const RefractElements& value, Functor& expand) {
+                RefractElements members;
+
+                for (RefractElements::const_iterator it = value.begin() ; it != value.end() ; ++it) {
+                    members.push_back(expand(*it));
+                }
+
+                return members;
+            }
+        };
+
+        ExtendElement* GetInheritanceTree(const std::string& name, const Registry& registry)
+        {
+            std::stack<IElement*> inheritance;
+            std::string en = name;
+
+            // FIXME: add check against recursive inheritance
+            // walk recursive in registry and expand inheritance tree
+            for (const IElement* parent = registry.find(en)
+                ; parent && !isReserved(en)
+                ; en = parent->element(), parent = registry.find(en)) {
+
+                inheritance.push(parent->clone((IElement::cAll ^ IElement::cElement) | IElement::cNoMetaId));
+                inheritance.top()->meta["ref"] = IElement::Create(en);
+            }
+
+            ExtendElement* e = new ExtendElement;
+
+            while (!inheritance.empty()) {
+                e->push_back(inheritance.top());
+                inheritance.pop();
+            }
+
+            // FIXME: posible solution while referenced type is not found in regisry
+            // \see test/fixtures/mson-resource-unresolved-reference.apib
+            //
+            //if (e->value.empty()) {
+            //   e->meta["ref"] = IElement::Create(name);
+            //}
+
+            return e;
+        }
+    } // anonymous namespace
+
+    struct ExpandVisitor::Context {
+
+        const Registry& registry;
+        ExpandVisitor* expand;
+
+        Context(const Registry& registry, ExpandVisitor* expand) : registry(registry), expand(expand) {}
+
+        IElement* ExpandOrClone(const IElement* e)
+        {
+            IElement* result = NULL;
+            if (!e) {
+                return result;
+            }
+
+            VisitBy(*e, *expand);
+            result = expand->get();
+
+            if (!result) {
+                result = e->clone();
+            }
+
+            return result;
+        }
+
+        template <typename V>
+        V ExpandValue(const V& v) {
+            auto expandOrClone = std::bind(&ExpandVisitor::Context::ExpandOrClone, this, std::placeholders::_1);
+            return ExpandValueImpl<V>()(v, expandOrClone);
+        }
+
+        template<typename T>
+        T* ExpandMembers(const T& e)
+        {
+            T* o = new T;
+            o->attributes.clone(e.attributes);
+            o->meta.clone(e.meta);
+
+            if (!e.empty()) {
+                o->set(ExpandValue(e.value));
+            }
+
+            return o;
+        }
+
+        std::deque<std::string> members;
+
+        template <typename T>
+        IElement* ExpandNamedType(const T& e)
+        {
+            
+            // Look for Circular Reference thro members
+            if (std::find(members.begin(), members.end(), e.element()) != members.end()) {
+                // To avoid unfinised recursion just clone
+                const IElement* root = FindRootAncestor(e.element(), registry);
+                // FIXME: if not found root
+                IElement* result = root->clone(IElement::cMeta | IElement::cAttributes | IElement::cNoMetaId);
+                result->meta["ref"] = IElement::Create(e.element());
+                return result;
+            }
+
+            members.push_back(e.element());
+
+            ExtendElement* tree = GetInheritanceTree(e.element(), registry);
+            ExtendElement* extend = ExpandMembers(*tree);
+            delete tree;
+
+            CopyMetaId(*extend, e);
+
+            members.pop_back();
+
+            T* origin = ExpandMembers(e);
+            origin->meta.erase("id");
+
+            extend->push_back(origin);
+
+            return extend;
+        }
+
+        template <typename T>
+        T* ExpandReference(const T& e)
+        {
+
+            T* ref = static_cast<T*>(e.clone());
+
+            MemberElement *m = FindMemberByKey(e, "href");
+            if (!m) {
+                return NULL;
+            }
+
+            StringElement* href = TypeQueryVisitor::as<StringElement>(m->value.second);
+            if (!href || href->value.empty()) {
+                return ref;
+            }
+
+            if (std::find(members.begin(), members.end(), href->value) != members.end()) {
+
+                std::stringstream msg;
+                msg <<  "named type '";
+                msg << href->value;
+                msg << "' is circularly referencing itself by mixin";
+
+                throw snowcrash::Error(msg.str(), snowcrash::MSONError);
+            }
+
+            members.push_back(href->value);
+
+            if (IElement* referenced = registry.find(href->value)) {
+                referenced = ExpandOrClone(referenced);
+                MetaIdToRef(*referenced);
+                referenced->renderType(IElement::rFull);
+                ref->attributes["resolved"] = referenced;
+            }
+
+            members.pop_back();
+
+            return ref;
+        }
+
+    };
+
+    template <typename T, typename V = typename T::ValueType>
+    struct ExpandElement {
+        IElement* result;
+
+        ExpandElement(const T& e, ExpandVisitor::Context* context) : result(NULL) {
+
+            if (!isReserved(e.element())) { // expand named type
+                result = context->ExpandNamedType(e);
+            }
+        }
+
+        operator IElement* () {
+            return result;
+        }
+    };
+
+    template <typename T>
+    struct ExpandElement<T, SelectElement::ValueType> {
+        IElement* result;
+
+        ExpandElement(const T& e, ExpandVisitor::Context* context) : result(NULL) {
+
+            if (!Expandable(e)) {  // do we have some expandable members?
+                return;
+            }
+
+            T* o = new T;
+            o->meta.clone(e.meta);
+
+            for (std::vector<OptionElement*>::const_iterator it = e.value.begin(); it != e.value.end(); ++it) {
+                o->push_back(static_cast<OptionElement*>(context->ExpandOrClone(*it)));
+            }
+
+            result = o;
+        }
+
+        operator IElement* () {
+            return result;
+        }
+    };
+
+    template <typename T>
+    struct ExpandElement<T, RefractElements> {
+        IElement* result;
+
+        ExpandElement(const T& e, ExpandVisitor::Context* context) : result(NULL) {
+
+            if (!Expandable(e)) {  // do we have some expandable members?
+                return;
+            }
+
+            std::string en = e.element();
+
+            if (!isReserved(en)) { // expand named type
+                result = context->ExpandNamedType(e);
+            }
+            else if (en == "ref") { // expand reference
+                result = context->ExpandReference(e);
+            }
+            else { // walk throught members and expand them
+                result = context->ExpandMembers(e);
+            }
+        }
+
+        operator IElement* () {
+            return result;
+        }
+    };
+
+    template <typename T>
+    struct ExpandElement<T, MemberElement::ValueType> {
+        IElement* result;
+
+        ExpandElement(const T& e, ExpandVisitor::Context* context) : result(NULL) {
+
+            if (!Expandable(e)) {
+                return;
+            }
+
+            MemberElement* expanded = static_cast<MemberElement*>(e.clone(IElement::cAll ^ IElement::cValue));
+            expanded->set(context->ExpandOrClone(e.value.first), context->ExpandOrClone(e.value.second));
+
+            result = expanded;
+        }
+
+        operator IElement* () {
+            return result;
+        }
+    };
+
+    template <typename T>
+    inline IElement* Expand(const T& e, ExpandVisitor::Context* context) {
+        return ExpandElement<T>(e, context);
+    }
+
+    ExpandVisitor::ExpandVisitor(const Registry& registry) : result(NULL), context(new Context(registry, this)) {};
+
+    ExpandVisitor::~ExpandVisitor() {
+        delete context;
+    }
+
+    void ExpandVisitor::operator()(const IElement& e) {
+        VisitBy(e, *this);
+    }
+    
+    // do nothing, NullElements are not expandable
+    void ExpandVisitor::operator()(const NullElement& e) {}
+
+    VISIT_IMPL(String)
+    VISIT_IMPL(Number)
+    VISIT_IMPL(Boolean)
+    VISIT_IMPL(Member)
+    VISIT_IMPL(Array)
+    VISIT_IMPL(Enum)
+    VISIT_IMPL(Object)
+    VISIT_IMPL(Extend)
+    VISIT_IMPL(Option)
+    VISIT_IMPL(Select)
+
+    IElement* ExpandVisitor::get() const {
+        return result;
+    }
+
+}; // namespace refract
+
+#undef VISIT_IMPL

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

@@ -0,0 +1,58 @@
+//
+//  refract/ExpandVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef REFRACT_EXPANDVISITOR_H
+#define REFRACT_EXPANDVISITOR_H
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    class Registry;
+
+    class ExpandVisitor {
+
+    public:
+        struct Context;
+
+        ExpandVisitor(const Registry& registry);
+        ~ExpandVisitor();
+
+        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 MemberElement& e);
+
+        void operator()(const ArrayElement& e);
+        void operator()(const EnumElement& e);
+        void operator()(const ObjectElement& e);
+
+        void operator()(const ExtendElement& e);
+
+        void operator()(const OptionElement& e);
+        void operator()(const SelectElement& e);
+
+        // return expanded elemnt or NULL if expansion is not needed
+        // caller responsibility is to delete returned Element
+        IElement* get() const;
+
+    private:
+
+        IElement* result;
+        Context* context;
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_EXPANVISITOR_H

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

@@ -0,0 +1,52 @@
+//
+//  refract/FilterVisitor.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 10/06/16.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_FILTERVISITOR_H
+#define REFRACT_FILTERVISITOR_H
+
+#include "ElementFwd.h"
+#include "Visitor.h"
+
+#include "Query.h"
+#include <vector>
+
+namespace refract
+{
+
+    class FilterVisitor
+    {
+        typedef std::vector<const IElement*> Elements;
+
+        Elements selected;
+        query::Query query;
+
+        public:
+
+        template <typename Predicate>
+        FilterVisitor(Predicate predicate) : query(predicate) {};
+
+        template <typename T>
+        void operator()(const T& e){
+
+            if(query(e)) {
+                selected.push_back(&e);
+            }
+        };
+
+        bool empty() const {
+            return selected.empty();
+        }
+
+        const Elements& elements() const {
+            return selected;
+        }
+
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_FILTERVISITOR_H

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

@@ -0,0 +1,140 @@
+//
+//  refract/IsExpandableVisitor.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#include "Element.h"
+#include "IsExpandableVisitor.h"
+
+namespace refract
+{
+
+    namespace
+    {
+        struct CheckElement {
+            bool checkElement(const IElement* e) const {
+                std::string type;
+
+                if (e) {
+                    type = e->element();
+                }
+
+                return !isReserved(type) || type == "ref" ;
+            }
+        };
+
+        template <typename T, typename V = typename T::ValueType>
+        struct IsExpandable : public CheckElement {
+            bool operator()(const T* e) const {
+
+                if (checkElement(e)) {
+                    return true;
+                }
+
+                return false;
+            }
+        };
+
+        template <typename T>
+        struct IsExpandable<T, SelectElement::ValueType> : public CheckElement {
+            bool operator()(const T* e) const {
+
+                if (checkElement(e)) {
+                    return true;
+                }
+
+                for (std::vector<OptionElement*>::const_iterator i = e->value.begin() ; i != e->value.end() ; ++i ) {
+                    IsExpandableVisitor v;
+                    VisitBy(*(*i), v);
+
+                    if (v.get()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        };
+
+        template <typename T>
+        struct IsExpandable<T, MemberElement::ValueType> : public CheckElement {
+            bool operator()(const T* e) const {
+
+                if (checkElement(e)) {
+                    return true;
+                }
+
+                if (e->value.first) {
+                    IsExpandableVisitor v;
+                    VisitBy(*e->value.first, v);
+                    if (v.get()) {
+                        return true;
+                    }
+                }
+
+                if (e->value.second) {
+                    IsExpandableVisitor v;
+                    VisitBy(*e->value.second, v);
+                    if (v.get()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        };
+
+        template <typename T>
+        struct IsExpandable<T, RefractElements> : public CheckElement {
+            bool operator()(const T* e) const {
+
+                if (checkElement(e)) {
+                    return true;
+                }
+
+                for (std::vector<IElement*>::const_iterator i = e->value.begin() ; i != e->value.end() ; ++i ) {
+                    IsExpandableVisitor v;
+                    VisitBy(*(*i), v);
+
+                    if (v.get()) {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        };
+    } // anonymous namespace
+
+    IsExpandableVisitor::IsExpandableVisitor() : result(false) {}
+
+    template<typename T>
+    void IsExpandableVisitor::operator()(const T& e) {
+        result = IsExpandable<T>()(&e);
+    }
+
+    template<>
+    void IsExpandableVisitor::operator()(const IElement& e) {
+        VisitBy(e, *this);
+    }
+
+    // Explicit instantioning of templates to avoid Linker Error
+    template void IsExpandableVisitor::operator()<NullElement>(const NullElement&);
+    template void IsExpandableVisitor::operator()<StringElement>(const StringElement&);
+    template void IsExpandableVisitor::operator()<NumberElement>(const NumberElement&);
+    template void IsExpandableVisitor::operator()<BooleanElement>(const BooleanElement&);
+    template void IsExpandableVisitor::operator()<ArrayElement>(const ArrayElement&);
+    template void IsExpandableVisitor::operator()<EnumElement>(const EnumElement&);
+    template void IsExpandableVisitor::operator()<MemberElement>(const MemberElement&);
+    template void IsExpandableVisitor::operator()<ObjectElement>(const ObjectElement&);
+    template void IsExpandableVisitor::operator()<ExtendElement>(const ExtendElement&);
+    template void IsExpandableVisitor::operator()<OptionElement>(const OptionElement&);
+    template void IsExpandableVisitor::operator()<SelectElement>(const SelectElement&);
+
+    bool IsExpandableVisitor::get() const {
+        return result;
+    }
+
+}; // namespace refract