lounge_lizard 0.1.0

data/ext/drafter/ext/sos/src/sosJSON.h

@@ -0,0 +1,121 @@
+//
+//  sosJSON.h
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 11/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SOS_JSON_H
+#define SOS_JSON_H
+
+#include <sstream>
+#include "sos.h"
+
+namespace sos {
+
+    struct SerializeJSON : public Serialize {
+
+        virtual void indent(size_t level, std::ostream& os) {
+
+            for (size_t i = 0; i < level; ++i) {
+                os << "  ";
+            }
+        }
+
+        virtual void null(std::ostream& os) {
+
+            os << "null";
+        }
+
+        virtual void string(const std::string& value, std::ostream& os) {
+
+            std::string normalized = escapeBackslashes(value);
+            normalized = escapeDoubleQuotes(normalized);
+            normalized = escapeNewlines(normalized);
+
+            os << "\"" << normalized << "\"";
+        }
+
+        /// Prints the given double to the output stream
+        /// Note: Does not print scientific notation
+        virtual void number(double value, std::ostream& os) {
+
+            std::stringstream output;
+            output << std::fixed << value;
+            std::string stringValue = output.str();
+
+            // "std:fixed" output always shows the decimal place and any
+            // leading zero's. Let's trim those out if there are any:
+            size_t position = stringValue.find_last_not_of("0");
+            if (stringValue.at(position) == '.') {
+                --position;
+            }
+            stringValue.resize(position + 1);
+
+            os << stringValue;
+        }
+
+        virtual void boolean(bool value, std::ostream& os) {
+
+            os << (value ? "true" : "false");
+        }
+
+        virtual void array(const Base& value, std::ostream& os, size_t level) {
+
+            os << "[";
+
+            if (!value.array().empty()) {
+
+                os << "\n";
+                size_t i = 0;
+
+                for (Bases::const_iterator it = value.array().begin(); it != value.array().end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.array().size()) {
+                        os << ",\n";
+                    }
+
+                    indent(level + 1, os);
+                    process(*it, os, level + 1);
+                }
+
+                os << "\n";
+                indent(level, os);
+            }
+
+            os << "]";
+        }
+
+        virtual void object(const Base& value, std::ostream& os, size_t level) {
+
+            os << "{";
+
+            if (!value.keys.empty()) {
+
+                os << "\n";
+                size_t i = 0;
+
+                for (Keys::const_iterator it = value.keys.begin(); it != value.keys.end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.keys.size()) {
+                        os << ",\n";
+                    }
+
+                    indent(level + 1, os);
+                    string(*it, os);
+
+                    os << ": ";
+                    process(value.object().at(*it), os, level + 1);
+                }
+
+                os << "\n";
+                indent(level, os);
+            }
+
+            os << "}";
+        }
+    };
+}
+
+#endif

data/ext/drafter/ext/sos/src/sosYAML.h

@@ -0,0 +1,105 @@
+//
+//  sosYAML.h
+//  sos
+//
+//  Created by Pavan Kumar Sunkara on 12/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SOS_YAML_H
+#define SOS_YAML_H
+
+#include "sos.h"
+
+namespace sos {
+
+    struct SerializeYAML : public Serialize {
+
+        virtual void indent(size_t level, std::ostream& os) {
+
+            for (size_t i = 0; i < level; ++i) {
+                os << "  ";
+            }
+        }
+
+        virtual void null(std::ostream& os) {
+
+            os << " " << "null";
+        }
+
+        virtual void string(const std::string& value, std::ostream& os) {
+
+            std::string normalized = escapeBackslashes(value);
+            normalized = escapeDoubleQuotes(normalized);
+            normalized = escapeNewlines(normalized);
+
+            os << " " << "\"" << normalized << "\"";
+        }
+
+        virtual void number(double value, std::ostream& os) {
+
+            os << " " << value;
+        }
+
+        virtual void boolean(bool value, std::ostream& os) {
+
+            os << " " << (value ? "true" : "false");
+        }
+
+        virtual void array(const Base& value, std::ostream& os, size_t level) {
+
+            if (!value.array().empty()) {
+
+                if (level > 0) {
+                    os << "\n";
+                }
+
+                size_t i = 0;
+
+                for (Bases::const_iterator it = value.array().begin(); it != value.array().end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.array().size()) {
+                        os << "\n";
+                    }
+
+                    indent(level, os);
+                    os << "-";
+                    process(*it, os, level + 1);
+                }
+            }
+            else {
+                os << " []";
+            }
+        }
+
+        virtual void object(const Base& value, std::ostream& os, size_t level) {
+
+            if (!value.keys.empty()) {
+
+                if (level > 0) {
+                    os << "\n";
+                }
+
+                size_t i = 0;
+
+                for (Keys::const_iterator it = value.keys.begin(); it != value.keys.end(); ++i, ++it) {
+
+                    if (i > 0 && i < value.keys.size()) {
+                        os << "\n";
+                    }
+                    
+                    indent(level, os);
+                    os << *it;
+                    
+                    os << ":";
+                    process(value.object().at(*it), os, level + 1);
+                }
+            }
+            else {
+                os << " {}";
+            }
+        }
+    };
+}
+
+#endif

data/ext/drafter/src/ConversionContext.cc

@@ -0,0 +1,39 @@
+//
+//  ConversionContext.cc
+//  drafter
+//
+//  Created by Pavan Kumar Sunkara on 18/08/16.
+//  Copyright © 2016 Apiary. All rights reserved.
+//
+
+#include "ConversionContext.h"
+
+namespace drafter {
+
+    void ConversionContext::warn(const snowcrash::Warning& warning)
+    {
+        for (auto& item : warnings) {
+            bool equalSourceMap = true;
+
+            // Compare sourcemap
+            if (item.location.size() == warning.location.size()) {
+                for (size_t i = 0; i < item.location.size(); i++) {
+                    if (item.location.at(i).length != warning.location.at(i).length ||
+                        item.location.at(i).location != warning.location.at(i).location) {
+
+                        equalSourceMap = false;
+                    }
+                }
+            }
+            else {
+                equalSourceMap = false;
+            }
+
+            if (equalSourceMap && item.code == warning.code && item.message == warning.message) {
+                return;
+            }
+        }
+
+        warnings.push_back(warning);
+    }
+}

data/ext/drafter/src/ConversionContext.h

@@ -0,0 +1,34 @@
+//
+//  ConversionContext.h
+//  drafter
+//
+//  Created by Jiri Kratochvil on 06-04-2016
+//  Copyright (c) 2016 Apiary Inc. All rights reserved.
+//
+#ifndef DRAFTER_CONVERSIONCONTEXT_H
+#define DRAFTER_CONVERSIONCONTEXT_H
+
+#include "refract/Registry.h"
+#include "snowcrash.h"
+
+namespace drafter {
+
+    struct WrapperOptions;
+
+    class ConversionContext {
+        refract::Registry registry;
+
+    public:
+        const WrapperOptions& options;
+        std::vector<snowcrash::Warning> warnings;
+
+        inline refract::Registry& GetNamedTypesRegistry() { return registry; }
+
+        ConversionContext(const WrapperOptions& options)
+        : options(options) {}
+
+        void warn(const snowcrash::Warning& warning);
+    };
+
+}
+#endif // #ifndef DRAFTER_CONVERSIONCONTEXT_H

data/ext/drafter/src/NamedTypesRegistry.cc

@@ -0,0 +1,405 @@
+#include "NamedTypesRegistry.h"
+
+#include <string>
+#include <map>
+#include <set>
+
+#include "MSON.h"
+#include "Blueprint.h"
+
+#include "NodeInfo.h"
+
+#include "refract/Registry.h"
+#include <algorithm>
+
+#include "RefractDataStructure.h"
+#include "RefractElementFactory.h"
+
+#include "ConversionContext.h"
+
+#undef DEBUG_DEPENDENCIES
+
+#ifdef DEBUG_DEPENDENCIES
+#include <iostream>
+#endif /* DEBUG_DEPENDENCIES */
+
+namespace drafter {
+
+    namespace {
+
+        typedef std::vector<NodeInfo<snowcrash::DataStructure> > DataStructures;
+
+        void FindNamedTypes(NodeInfoCollection<snowcrash::Elements>& elements, DataStructures& found)
+        {
+
+            for (NodeInfoCollection<snowcrash::Elements>::const_iterator i = elements.begin(); i != elements.end(); ++i) {
+
+                if (i->node->element == snowcrash::Element::DataStructureElement) {
+                    found.push_back(MakeNodeInfo(i->node->content.dataStructure, i->sourceMap->content.dataStructure));
+                }
+                else if (!i->node->content.resource.attributes.empty()) {
+                    found.push_back(MakeNodeInfo(i->node->content.resource.attributes, i->sourceMap->content.resource.attributes));
+                }
+                else if (i->node->element == snowcrash::Element::CategoryElement) {
+                    NodeInfoCollection<snowcrash::Elements> children(MakeNodeInfo(i->node->content.elements(), i->sourceMap->content.elements()));
+                    FindNamedTypes(children, found);
+                }
+            }
+        }
+
+        struct DependencyTypeInfo {
+
+            typedef std::map<std::string, std::string> InheritanceMap;
+            InheritanceMap childToParent;
+
+            typedef std::set<std::string> Members;
+            typedef std::map<std::string, Members> MembersMap;
+
+            MembersMap objectToMembers;
+
+            typedef std::map<std::string, const snowcrash::DataStructure*> ElementMap;
+            ElementMap nameToElement;
+
+            const std::string& parent(const snowcrash::DataStructure* ds) const {
+                return ds->typeDefinition.typeSpecification.name.symbol.literal;
+            }
+
+            bool hasParent(const snowcrash::DataStructure* ds) const {
+                return !parent(ds).empty();
+            }
+
+            const std::string& name(const mson::TypeName& tn) const {
+                return tn.symbol.literal;
+            }
+
+            const std::string& name(const snowcrash::DataStructure* ds) const {
+                return ds->name.symbol.literal;
+            }
+
+            const std::string& name(const mson::TypeSpecification& ts) const {
+                return ts.name.symbol.literal;
+            }
+
+            const std::string& name(const mson::ValueDefinition& vd) const {
+                return name(vd.typeDefinition.typeSpecification);
+            }
+
+            const std::string& name(const mson::ValueMember& vm) const {
+                return name(vm.valueDefinition);
+            }
+
+            const std::string& name(const mson::PropertyMember& pm) const {
+                return name(pm.valueDefinition);
+            }
+
+            const std::string& name(const mson::Mixin& mx) const {
+                return name(mx.typeSpecification);
+            }
+
+            Members collectMembers(const mson::Elements& elements) {
+                Members members;
+
+                for (mson::Elements::const_iterator it = elements.begin() ; it != elements.end() ; ++it) {
+
+                    std::string member;
+                    const mson::TypeSections* ts = NULL;
+                    const mson::TypeNames* tn = NULL;
+
+                    if (!it->content.value.empty() ) {
+                        if (!name(it->content.value).empty()) {
+                            member = name(it->content.value);
+                        }
+                        else {
+                            ts = &it->content.value.sections;
+                        }
+                    }
+                    else if (!it->content.property.empty()) {
+                        if(!name(it->content.property).empty()) {
+                            member = name(it->content.property);
+                        }
+                        else if (!name(it->content.property.name.variable).empty()) {
+                            member = name(it->content.property.name.variable);
+                        }
+                        else if (!it->content.property.valueDefinition.typeDefinition.typeSpecification.nestedTypes.empty()) {
+                            // - name (array|enum[<nested>, <type>])
+                            tn = &it->content.property.valueDefinition.typeDefinition.typeSpecification.nestedTypes;
+                        }
+                        else {
+                            ts = &it->content.property.sections;
+                        }
+                    }
+                    else if (!it->content.mixin.empty()) {
+                        if (!name(it->content.mixin).empty()) {
+                            member = name(it->content.mixin);
+                        }
+                    }
+
+                    if (!member.empty()) {
+                        members.insert(member);
+                    }
+                    else if (ts) {
+                        Members sub = collectMembers(*ts);
+                        members.insert(sub.begin(), sub.end());
+                    }
+                    else if (tn) {
+                        Members sub = collectMembers(*tn);
+                        members.insert(sub.begin(), sub.end());
+                    }
+                }
+
+                return members;
+            }
+
+            Members collectMembers(const mson::TypeSections& ts) {
+                Members members;
+
+                // map direct members
+                for (mson::TypeSections::const_iterator its = ts.begin() ; its != ts.end() ; ++its) {
+                    Members sub = collectMembers(its->content.elements());
+                    members.insert(sub.begin(), sub.end());
+                }
+
+                return members;
+            }
+
+            Members collectMembers(const mson::TypeNames& tn) {
+                Members members;
+
+                for (mson::TypeNames::const_iterator itn = tn.begin() ; itn != tn.end() ; ++itn) {
+                    members.insert(name(*itn));
+                }
+
+                return members;
+            }
+
+            Members collectMembers(const snowcrash::DataStructure* ds) {
+                return collectMembers(ds->sections);
+            }
+
+            Members collectMembers(const std::string& id, const MembersMap& members, Members& resolved) {
+                Members collected;
+
+                if (resolved.find(id) != resolved.end()) {
+                    return collected;
+                }
+
+                resolved.insert(id);
+
+                MembersMap::const_iterator member = members.find(id);
+                if (member == members.end()) {
+                    return collected;
+                }
+
+                for (Members::const_iterator i = member->second.begin() ; i != member->second.end() ; ++i) {
+                    Members sub = collectMembers(*i, members, resolved);
+                    collected.insert(*i);
+                    collected.insert(sub.begin(), sub.end());
+                }
+
+                return collected;
+            }
+
+            DependencyTypeInfo(const DataStructures& elements) {
+
+                // map inheritance && element
+                for (DataStructures::const_iterator i = elements.begin() ; i != elements.end() ; ++i) {
+
+                    nameToElement[name(i->node)] = &(*i->node);
+
+                    if (hasParent(i->node)) {
+                        childToParent[name(i->node)] = parent(i->node);
+
+#ifdef DEBUG_DEPENDENCIES
+                        std::cout << "Parent: " << name(i->node) << "=>" << parent(i->node) << std::endl;
+#endif
+
+                    }
+                }
+
+                // Map members
+                MembersMap members;
+                for (DataStructures::const_iterator i = elements.begin() ; i != elements.end() ; ++i) {
+                    members[name(i->node)] = collectMembers(i->node);
+                }
+
+                // Map members into deep
+                for (MembersMap::const_iterator i = members.begin() ; i != members.end() ; ++i) {
+                    Members resolved;
+                    objectToMembers[i->first] = collectMembers(i->first, members, resolved);
+                }
+
+#ifdef DEBUG_DEPENDENCIES
+                // debug out members
+                for (MembersMap::const_iterator i = objectToMembers.begin() ; i != objectToMembers.end() ; ++i) {
+                    std::cout << "Members: " << i->first << std::endl;
+                    for (Members::const_iterator it = objectToMembers[i->first].begin() ; it != objectToMembers[i->first].end() ; ++it) {
+                        std::cout << " - " << *it << std::endl;
+                    }
+                }
+#endif /* DEBUG_DEPENDENCIES */
+
+            }
+
+            bool hasMember(const snowcrash::DataStructure* object, const snowcrash::DataStructure* member) const {
+                MembersMap::const_iterator members = objectToMembers.find(name(object));
+                if (members == objectToMembers.end()) {
+                    return false;
+                }
+
+                return members->second.find(name(member)) != members->second.end();
+            }
+
+            bool hasAncestor(const snowcrash::DataStructure* object, const snowcrash::DataStructure* ancestor) const {
+                std::string s = name(object);
+                const std::string& isAncestor = name(ancestor);
+
+                while(!s.empty()) {
+                    if (s == isAncestor) {
+                        return true;
+                    }
+
+                    InheritanceMap::const_iterator i = childToParent.find(s);
+                    if (i == childToParent.end()) {
+                        return false;
+                    }
+
+                    s = i->second;
+                }
+
+                return false;
+            }
+
+            mson::BaseTypeName GetType(const snowcrash::DataStructure* ds) const {
+                return ds->typeDefinition.typeSpecification.name.base;
+            }
+
+            mson::BaseTypeName ResolveType(const snowcrash::DataStructure* object) const {
+                std::string s = name(object);
+
+                while(!s.empty()) {
+                    ElementMap::const_iterator ei = nameToElement.find(s);
+                    if (ei == nameToElement.end()) {
+                        return mson::UndefinedTypeName;
+                    }
+
+                    mson::BaseTypeName type = GetType(ei->second);
+
+                    if ( type != mson::UndefinedTypeName) {
+                        return type;
+                    }
+
+                    InheritanceMap::const_iterator i = childToParent.find(s);
+                    if (i == childToParent.end() || (s == i->second)) {
+                        return mson::UndefinedTypeName;
+                    }
+
+                    s = i->second;
+                }
+
+                return mson::UndefinedTypeName;
+            }
+
+        };
+
+        struct InheritanceComparator {
+
+            const DependencyTypeInfo& typeInfo;
+
+            InheritanceComparator(const DependencyTypeInfo& typeInfo) : typeInfo(typeInfo) {}
+
+            /* This is a comparator for std::sort so it has to compare
+             * objects in strictly weak ordering otherwise it would crash
+             * with sort going out of container bounds, see
+             * http://stackoverflow.com/questions/24048022/what-causes-stdsort-to-access-address-out-of-range
+             * for more details.
+             * The order is following, if F has S as an ancestor or a member
+             * then S < F and conversely, if none of this applies we compare objects by
+             * names to provide some ordering for all objects as we don't
+             * really care.
+             */
+            bool operator()(DataStructures::const_reference first, DataStructures::const_reference second) {
+
+                if (typeInfo.hasAncestor(first.node, second.node) || typeInfo.hasMember(first.node, second.node)) {
+                    return false;
+                }
+
+                if (typeInfo.hasAncestor(second.node, first.node) || typeInfo.hasMember(second.node, first.node)) {
+                    return true;
+                }
+
+                return typeInfo.name(first.node) < typeInfo.name(second.node);
+            }
+        };
+
+    } // ns anonymous
+
+    void RegisterNamedTypes(const NodeInfo<snowcrash::Elements>& elements, ConversionContext& context)
+    {
+        DataStructures found;
+        NodeInfoCollection<snowcrash::Elements> elementCollection(elements);
+
+        FindNamedTypes(elementCollection, found);
+
+#ifdef DEBUG_DEPENDENCIES
+        std::cout << "==DEPENDENCIES INFO BEGIN==" << std::endl;
+#endif /* DEBUG_DEPENDENCIES */
+
+        DependencyTypeInfo typeInfo(found);
+
+        std::sort(found.begin(), found.end(), InheritanceComparator(typeInfo));
+
+#ifdef DEBUG_DEPENDENCIES
+        std::cout << "==BASE TYPE ORDER==" << std::endl;
+#endif /* DEBUG_DEPENDENCIES */
+
+        // first level registration - we will create empty elements with correct type info
+        for (DataStructures::const_iterator i = found.begin(); i != found.end(); ++i) {
+            const std::string& name = i->node->name.symbol.literal;
+
+            const RefractElementFactory& factory = FactoryFromType(typeInfo.ResolveType(i->node));
+            refract::IElement* element = factory.Create(std::string(), eValue);
+            element->meta["id"] = refract::IElement::Create(name);
+
+            try {
+                context.GetNamedTypesRegistry().add(element);
+            } catch (refract::LogicError& e) {
+                std::ostringstream out;
+                out << name  << " is a reserved keyword and cannot be used.";
+                throw snowcrash::Error(out.str(), snowcrash::MSONError, i->sourceMap->name.sourceMap);
+            }
+        }
+
+        for (DataStructures::const_iterator i = found.begin(); i != found.end(); ++i) {
+
+            if (!i->node->name.symbol.literal.empty()) {
+
+                const std::string& name = i->node->name.symbol.literal;
+                refract::IElement* element = MSONToRefract(*i, context);
+
+#ifdef DEBUG_DEPENDENCIES
+                refract::TypeQueryVisitor v;
+                v.visit(*element);
+                std::cout << name << " [" << v.get() << "]" << std::endl;
+#endif /* DEBUG_DEPENDENCIES */
+
+                // remove preregistrated element
+                refract::IElement* pre = context.GetNamedTypesRegistry().find(name);
+                context.GetNamedTypesRegistry().remove(name);
+                delete pre;
+
+                try {
+                    context.GetNamedTypesRegistry().add(element);
+                } catch (refract::LogicError& e) {
+                    std::ostringstream out;
+                    out << name  << " is a reserved keyword and cannot be used.";
+                    throw snowcrash::Error(out.str(), snowcrash::MSONError, i->sourceMap->name.sourceMap);
+                }
+            }
+        }
+
+#ifdef DEBUG_DEPENDENCIES
+        std::cout << "==DEPENDENCIES INFO END==" << std::endl;
+#endif /* DEBUG_DEPENDENCIES */
+
+    }
+} // ns drafter