lounge_lizard 0.1.0

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

@@ -0,0 +1,73 @@
+//
+//  refract/JSONSchemaVisitor.h
+//  librefract
+//
+//  Created by Vilibald Wanča on 09/11/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef REFRACT_JSONSCHEMAVISITOR_H
+#define REFRACT_JSONSCHEMAVISITOR_H
+
+#include "VisitorUtils.h"
+#include <string>
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+    class JSONSchemaVisitor 
+    {
+        ObjectElement *pObj;
+        ObjectElement *pDefs;
+        bool fixed;
+        bool fixedType;
+
+        void setSchemaType(const std::string& type);
+        void addSchemaType(const std::string& type);
+        void addMember(const std::string& key, IElement *val);
+        void anyOf(std::map<std::string, std::vector<IElement*> >& types, std::vector<std::string>& typesOrder);
+        bool allItemsEmpty(const ArrayElement::ValueType* val);
+        ObjectElement* definitionFromVariableProperty(JSONSchemaVisitor& renderer);
+        void addVariableProps(std::vector<MemberElement*>& props,ObjectElement *o);
+        ArrayElement* arrayFromProps(std::vector<MemberElement*>& props);
+
+        template<typename T>
+        void setPrimitiveType(const T& e)
+        {
+            //FIXME: static_assert is missing in our code base
+            //static_assert(sizeof(T) == 0, "Only String, Number, Boolean types allowed");
+
+            throw std::runtime_error("Only String, Number, Boolean types allowed");
+        };
+
+        template<typename T> void primitiveType(const T& e);
+
+    public:
+        JSONSchemaVisitor(ObjectElement *pDefinitions = NULL,
+                          bool _fixed = false,
+                          bool _fixedType = false);
+        ~JSONSchemaVisitor();
+        void setFixed(bool _fixed);
+        void setFixedType(bool _fixedType);
+        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);
+
+        void operator()(const OptionElement& e);
+
+        IElement* get();
+        IElement* getOwnership();
+        std::string getSchema(const IElement& e);
+    };
+}
+
+#endif

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

@@ -0,0 +1,164 @@
+//
+//  refract/PrintVisitor.cc
+//  librefract
+//
+//  Created by Vilibald Wanča on 09/11/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "VisitorUtils.h"
+#include <sstream>
+#include <iostream>
+
+#include "PrintVisitor.h"
+#include "Visitor.h"
+
+#define VISIT_IMPL( ELEMENT ) void PrintVisitor::operator()(const ELEMENT ## Element& e) \
+    {                                                                    \
+        typedef ELEMENT ## Element::ValueType::const_iterator iterator;  \
+        PrintVisitor ps(indent + 1, os);                                 \
+        Visitor visitor(ps);                                             \
+                                                                         \
+        os << "" #ELEMENT "Element  {\n";                                \
+        for (iterator it = e.value.begin(); it != e.value.end(); ++it) { \
+            visitor.visit(*(*it));                                       \
+        }                                                                \
+        indentOS(indent);                                                \
+        os << "}\n";                                                     \
+    }                                                                    \
+
+namespace refract
+{
+    PrintVisitor::PrintVisitor()
+    : indent(0), os(std::cout) {}
+
+    PrintVisitor::PrintVisitor(int indent_, std::ostream& os_)
+    : indent(indent_), os(os_) {}
+
+    void PrintVisitor::indentOS(int ind)
+    {
+        for (int i = 0; i < ind; i++) {
+            os << "  ";
+        }
+    }
+
+    void PrintVisitor::printMeta(const IElement& e)
+    {
+        if (e.meta.size() > 0) {
+            os << "meta {\n";
+            indentOS(indent);
+
+            for (IElement::MemberElementCollection::const_iterator i = e.meta.begin();
+                i != e.meta.end();
+                ++i) {
+
+                refract::Visit(*this, *(*i));
+            }
+
+            indentOS(indent);
+            os << "}\n";
+        }
+    }
+
+    void PrintVisitor::printAttr(const IElement& e)
+    {
+        if (e.attributes.size() > 0) {
+            os << "attributes {\n";
+            indentOS(indent);
+
+            for (IElement::MemberElementCollection::const_iterator i = e.attributes.begin();
+                i != e.attributes.end();
+                ++i) {
+
+                refract::Visit(*this, *(*i));
+            }
+
+            indentOS(indent);
+            os << "}\n";
+        }
+    }
+
+
+    void PrintVisitor::operator()(const IElement& e)
+    {
+        indentOS(indent);
+        printMeta(e);
+        printAttr(e);
+
+        VisitBy(e, *this);
+    }
+
+    void PrintVisitor::operator()(const NullElement& e)
+    {
+        os << "NullElement(null)" << "\n";
+    }
+
+    void PrintVisitor::operator()(const StringElement& e)
+    {
+        const StringElement::ValueType* v = GetValue<StringElement>(e);
+        os << "StringElement(" << *v << ")" << "\n";
+    }
+
+    void PrintVisitor::operator()(const NumberElement& e)
+    {
+        const NumberElement::ValueType* v = GetValue<NumberElement>(e);
+
+        os << "NumberElement(";
+        if (v) {
+            os << *v;
+        } else {
+            os << "null";
+        }
+        os << ")" << "\n";
+    }
+
+    void PrintVisitor::operator()(const BooleanElement& e)
+    {
+        const BooleanElement::ValueType* v = GetValue<BooleanElement>(e);
+
+        os << "BooleanElement(";
+        if (v) {
+            os << *v;
+        } else {
+            os << "null";
+        }
+        os << ")" << "\n";
+    }
+
+    void PrintVisitor::operator()(const MemberElement& e)
+    {
+        os << "MemberElement {\n";
+        indentOS(indent + 1);
+        if (e.value.first) {
+            if (StringElement* str = TypeQueryVisitor::as<StringElement>(e.value.first)) {
+                os<< "\"" << str->value << "\": \n";
+            } else {
+                throw std::logic_error("A property's key in the object is not of type string");
+            }
+        }
+
+        if (e.value.second) {
+            PrintVisitor ps(indent + 1, os);
+            refract::Visit(ps, *e.value.second);
+        }
+        indentOS(indent);
+        os << "}\n";
+    }
+
+
+    VISIT_IMPL(Array)
+    VISIT_IMPL(Enum)
+    VISIT_IMPL(Object)
+    VISIT_IMPL(Extend)
+    VISIT_IMPL(Option)
+    VISIT_IMPL(Select)
+
+    void PrintVisitor::Visit(const IElement& e)
+    {
+        PrintVisitor ps;
+        refract::Visit(ps, e);
+    }
+
+}; // namespace refract
+
+#undef VISIT_IMPL

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

@@ -0,0 +1,50 @@
+//
+//  refract/PrintVisitor.h
+//  librefract
+//
+//  Created by Vilibald Wanča on 09/11/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef REFRACT_PRINTVISITOR_H
+#define REFRACT_PRINTVISITOR_H
+
+#include <string>
+#include <ostream>
+
+#include "ElementFwd.h"
+
+namespace refract
+{
+
+    class PrintVisitor 
+    {
+        int indent;
+        std::ostream& os;
+
+        void indentOS(int ind);
+        void printMeta(const IElement& e);
+        void printAttr(const IElement& e);
+
+    public:
+        PrintVisitor();
+        PrintVisitor(int indentation, std::ostream& os);
+
+        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);
+        void operator()(const OptionElement& e);
+        void operator()(const SelectElement& e);
+
+        static void Visit(const IElement& e);
+    };
+}
+
+#endif

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

@@ -0,0 +1,13 @@
+#include "Query.h"
+#include "Element.h"
+
+namespace refract {
+
+    namespace query {
+
+            bool Element::operator()(const IElement& e) {
+                return e.element() == name;
+            }
+    }
+
+}

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

@@ -0,0 +1,38 @@
+//
+//  refract/Query.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 17/06/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_QUERY_H
+#define REFRACT_QUERY_H
+
+#include "ElementFwd.h"
+
+#include <functional>
+#include <string>
+
+namespace refract
+{
+
+    namespace query {
+
+        typedef std::function<bool(const IElement&)> Query;
+
+        class Element {
+            const std::string name;
+
+        public:
+
+            Element(const std::string& name) : name(name) {}
+
+            bool operator()(const IElement& e);
+
+        };
+
+    };
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_QUERY_H

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

@@ -0,0 +1,114 @@
+//
+//  refract/Registry.cc
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "Registry.h"
+#include "Element.h"
+#include "SerializeCompactVisitor.h"
+#include "TypeQueryVisitor.h"
+
+#include <algorithm>
+
+namespace refract
+{
+
+    IElement* FindRootAncestor(const std::string& name, const Registry& registry)
+    {
+        IElement* parent = registry.find(name);
+
+        while (parent && !isReserved(parent->element())) {
+            IElement* next = registry.find(parent->element());
+
+            if (!next || (next == parent)) {
+                return parent;
+            }
+
+            parent = next;
+        }
+
+        return parent;
+    }
+
+    std::string Registry::getElementId(IElement* element)
+    {
+        IElement::MemberElementCollection::const_iterator it = element->meta.find("id");
+
+        if (it == element->meta.end()) {
+            throw LogicError("Element has no ID");
+        }
+
+        // FIXME: remove dependecy on SosSerializeCompactVisitor
+        SosSerializeCompactVisitor v;
+        VisitBy(*(*it)->value.second, v);
+
+        if (StringElement* s = TypeQueryVisitor::as<StringElement>((*it)->value.second)) {
+            return s->value;
+        }
+
+        throw LogicError("Value of element meta 'id' is not StringElement");
+    }
+
+    IElement* Registry::find(const std::string& name) const
+    {
+        Map::const_iterator i = registrated.find(name);
+
+        if (i == registrated.end()) {
+            return NULL;
+        }
+
+        return i->second;
+    }
+
+    bool Registry::add(IElement* element)
+    {
+        IElement::MemberElementCollection::const_iterator it = element->meta.find("id");
+
+        if (it == element->meta.end()) {
+            throw LogicError("Element has no ID");
+        }
+
+        std::string id = getElementId(element);
+
+        if (isReserved(id)) {
+            throw LogicError("You can not register a basic element");
+        }
+
+        if (find(id)) {
+            // there is already already element with given name
+            return false;
+        }
+
+        registrated[id] = element;
+        return true;
+    }
+
+    bool Registry::remove(const std::string& name) {
+        Map::iterator i = registrated.find(name);
+
+        if (i == registrated.end()) {
+            return false;
+        }
+
+        registrated.erase(i);
+        return true;
+    }
+
+    template<typename T>
+    static void DeleteSecond(T& pair)
+    {
+        delete pair.second;
+    }
+
+    void Registry::clearAll(bool releaseElements) {
+        if (releaseElements) {
+            std::for_each(registrated.begin(), registrated.end(), DeleteSecond<Map::value_type>);
+        }
+
+        registrated.clear();
+    }
+
+}; // namespace refract

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

@@ -0,0 +1,43 @@
+//
+//  refract/Registry.h
+//  librefract
+//
+//  Created by Jiri Kratochvil on 21/05/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+#ifndef REFRACT_REGISTRY_H
+#define REFRACT_REGISTRY_H
+
+#include <map>
+#include <string>
+
+namespace refract
+{
+
+    // Forward declarations of IElement
+    struct IElement;
+
+    class Registry
+    {
+        // FIXME: potentionally dangerous,
+        // if element is deleted and not removed from registry
+        // solution: std::shared_ptr<> || std::weak_ptr<>
+        typedef std::map<std::string, IElement*> Map;
+        Map registrated;
+
+        std::string getElementId(IElement* element);
+
+    public:
+
+        IElement* find(const std::string& name) const;
+
+        bool add(IElement* element) ;
+        bool remove(const std::string& name);
+        void clearAll(bool releaseElements = false);
+    };
+
+    IElement* FindRootAncestor(const std::string& name, const Registry& registry);
+
+}; // namespace refract
+
+#endif // #ifndef REFRACT_REGISTRY_H