lounge_lizard 0.1.0

data/ext/drafter/ext/snowcrash/src/MSONPropertyMemberParser.h

@@ -0,0 +1,106 @@
+//
+//  MSONPropertyMemberParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/5/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONPROPERTYMEMBERPARSER_H
+#define SNOWCRASH_MSONPROPERTYMEMBERPARSER_H
+
+#include "MSONValueMemberParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /**
+     * MSON Property Member Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::PropertyMember> : public SignatureSectionProcessorBase<mson::PropertyMember> {
+
+        static Signature parseSignature(const MarkdownNodeIterator& node,
+                                        snowcrash::SectionParserData& pd,
+                                        const SignatureTraits& traits,
+                                        snowcrash::Report& report,
+                                        const mdp::ByteBuffer& subjectOrig = "") {
+
+            std::string subject = subjectOrig;
+
+            if (node->type == mdp::HeaderMarkdownNodeType) {
+                subject = ReconstructMarkdownHeader(*node);
+            }
+
+            return SignatureSectionProcessorBase<mson::PropertyMember>::parseSignature(node, pd, traits, report, subject);
+        }
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait |
+                                            SignatureTraits::ValuesTrait |
+                                            SignatureTraits::AttributesTrait |
+                                            SignatureTraits::ContentTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<mson::PropertyMember>& out) {
+
+            mson::parsePropertyName(node, pd, signature.identifier, out.report, out.node.name);
+
+            if (pd.exportSourceMap() && !out.node.name.empty()) {
+                out.sourceMap.name.sourceMap = node->sourceMap;
+            }
+
+            return SectionProcessor<mson::ValueMember>::useSignatureData(node, pd, signature, out.report, out.node, out.sourceMap);
+        }
+
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<mson::PropertyMember>& out) {
+
+            return SectionProcessor<mson::ValueMember>::blockDescription(node, pd, out.node.sections, out.sourceMap.sections);
+        }
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<mson::PropertyMember>& out) {
+
+            ParseResultRef<mson::TypeSections> typeSections(out.report, out.node.sections, out.sourceMap.sections);
+
+            return SectionProcessor<mson::ValueMember>
+                    ::processNestedMembers<MSONTypeSectionListParser>(node, siblings, pd, typeSections,
+                                                                      out.node.valueDefinition.typeDefinition.baseType);
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            return SectionProcessor<mson::ValueMember>::isDescriptionNode(node, sectionType);
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            return SectionProcessor<mson::ValueMember>::nestedSectionType(node);
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<mson::PropertyMember>& out) {
+
+            SectionProcessor<mson::ValueMember>::finalizeImplicitBaseType(out.node.valueDefinition.typeDefinition.baseType);
+        }
+    };
+
+    /** MSON Property Member Section Parser */
+    typedef SectionParser<mson::PropertyMember, ListSectionAdapter> MSONPropertyMemberParser;
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/MSONSourcemap.cc

@@ -0,0 +1,141 @@
+//
+//  MSONSourcemap.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 03/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "MSONSourcemap.h"
+
+using namespace snowcrash;
+
+bool SourceMap<mson::NamedType>::empty() const
+{
+    return (name.sourceMap.empty() &&
+            typeDefinition.sourceMap.empty() &&
+            sections.collection.empty());
+}
+
+bool SourceMap<mson::ValueMember>::empty() const
+{
+    return (description.sourceMap.empty() &&
+            valueDefinition.sourceMap.empty() &&
+            sections.collection.empty());
+}
+
+bool SourceMap<mson::PropertyMember>::empty() const
+{
+    return (name.sourceMap.empty() &&
+            description.sourceMap.empty() &&
+            valueDefinition.sourceMap.empty() &&
+            sections.collection.empty());
+}
+
+SourceMap<mson::Elements>& SourceMap<mson::TypeSection>::elements()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const SourceMap<mson::Elements>& SourceMap<mson::TypeSection>::elements() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+SourceMap<mson::TypeSection>::SourceMap(const SourceMap<mson::Markdown>& description_, const SourceMap<mson::Literal>& value_)
+: description(description_), value(value_)
+{
+    m_elements.reset(::new SourceMap<mson::Elements>);
+}
+
+SourceMap<mson::TypeSection>::SourceMap(const SourceMap<mson::TypeSection>& rhs)
+{
+    this->description = rhs.description;
+    this->value = rhs.value;
+    m_elements.reset(::new SourceMap<mson::Elements>(*rhs.m_elements.get()));
+}
+
+SourceMap<mson::TypeSection>& SourceMap<mson::TypeSection>::operator=(const SourceMap<mson::TypeSection>& rhs)
+{
+    this->description = rhs.description;
+    this->value = rhs.value;
+    m_elements.reset(::new SourceMap<mson::Elements>(*rhs.m_elements.get()));
+
+    return *this;
+}
+
+SourceMap<mson::TypeSection>::~SourceMap()
+{
+}
+
+SourceMap<mson::OneOf>& SourceMap<mson::Element>::oneOf()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const SourceMap<mson::OneOf>& SourceMap<mson::Element>::oneOf() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+SourceMap<mson::Elements>& SourceMap<mson::Element>::elements()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const SourceMap<mson::Elements>& SourceMap<mson::Element>::elements() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+SourceMap<mson::Element>& SourceMap<mson::Element>::operator=(const SourceMap<mson::Elements> &rhs)
+{
+    m_elements.reset(::new SourceMap<mson::Elements>(rhs));
+
+    return *this;
+}
+
+SourceMap<mson::Element>::SourceMap()
+{
+    m_elements.reset(::new SourceMap<mson::Elements>);
+}
+
+SourceMap<mson::Element>::SourceMap(const SourceMap<mson::Element>& rhs)
+{
+    this->property = rhs.property;
+    this->value = rhs.value;
+    this->mixin = rhs.mixin;
+    m_elements.reset(::new SourceMap<mson::Elements>(*rhs.m_elements.get()));
+}
+
+SourceMap<mson::Element>& SourceMap<mson::Element>::operator=(const SourceMap<mson::Element>& rhs)
+{
+    this->property = rhs.property;
+    this->value = rhs.value;
+    this->mixin = rhs.mixin;
+    m_elements.reset(::new SourceMap<mson::Elements>(*rhs.m_elements.get()));
+
+    return *this;
+}
+
+SourceMap<mson::Element>::~SourceMap()
+{
+}

data/ext/drafter/ext/snowcrash/src/MSONSourcemap.h

@@ -0,0 +1,181 @@
+//
+//  MSONSourcemap.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 10/23/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONSOURCEMAP_H
+#define SNOWCRASH_MSONSOURCEMAP_H
+
+#include "Blueprint.h"
+#include "MSON.h"
+#include "MarkdownParser.h"
+
+/**
+ * MSON Sourcemap Abstract Syntax Tree
+ * -----------------------------------
+ *
+ * Data types in this document define the MSON Sourcemap AST
+ */
+
+namespace snowcrash {
+
+    /**
+     * Default Container for collections.
+     *
+     *  FIXME: Use C++11 template aliases when migrating to C++11.
+     */
+}
+
+#define SOURCE_MAP_COLLECTION(T, TC) template<>\
+struct SourceMap<TC> {\
+    Collection<SourceMap<T> >::type collection;\
+};\
+
+namespace snowcrash {
+
+    struct SourceMapBase {
+        mdp::BytesRangeSet sourceMap;
+    };
+
+    template<typename T>
+    struct SourceMap : public SourceMapBase {
+    };
+
+    /** Source Map of Collection of Type Names */
+    SOURCE_MAP_COLLECTION(mson::TypeName, mson::TypeNames)
+
+    /** Forward Declaration for Source Map of Element */
+    template<>
+    struct SourceMap<mson::Element>;
+
+    /** Source Map of Collection of Elements */
+    SOURCE_MAP_COLLECTION(mson::Element, mson::Elements)
+
+    /** Source Map structure for Type Section */
+    template<>
+    struct SourceMap<mson::TypeSection> : public SourceMapBase {
+
+        /** EITHER Source Map of Block Description */
+        SourceMap<mson::Markdown> description;
+
+        /** OR Source Map of Literal */
+        SourceMap<mson::Literal> value;
+
+        /** OR Source Map of Collection of elements */
+        SourceMap<mson::Elements>& elements();
+        const SourceMap<mson::Elements>& elements() const;
+
+        /** Constructor */
+        SourceMap(const SourceMap<mson::Markdown>& description_ = SourceMap<mson::Markdown>(),
+                  const SourceMap<mson::Literal>& value_ = SourceMap<mson::Literal>());
+
+        /** Copy constructor */
+        SourceMap(const SourceMap<mson::TypeSection>& rhs);
+
+        /** Assignment operator */
+        SourceMap<mson::TypeSection>& operator=(const SourceMap<mson::TypeSection>& rhs);
+
+        /** Desctructor */
+        ~SourceMap();
+
+    private:
+        std::unique_ptr<SourceMap<mson::Elements> > m_elements;
+
+    };
+
+    /** Source Map of Collection of Type Sections */
+    SOURCE_MAP_COLLECTION(mson::TypeSection, mson::TypeSections)
+
+    /** Source Map structure for Named Type */
+    template<>
+    struct SourceMap<mson::NamedType> : public SourceMapBase {
+
+        /** Source Map of Type Name */
+        SourceMap<mson::TypeName> name;
+
+        /** Source Map of Type Definition */
+        SourceMap<mson::TypeDefinition> typeDefinition;
+
+        /** Source Map of Type Sections */
+        SourceMap<mson::TypeSections> sections;
+
+        /** Check if empty */
+        bool empty() const;
+    };
+
+    /** Source Map structure for Value Member */
+    template<>
+    struct SourceMap<mson::ValueMember> : public SourceMapBase {
+
+        /** Source Map of Description */
+        SourceMap<mson::Markdown> description;
+
+        /** Source Map of Value Definition */
+        SourceMap<mson::ValueDefinition> valueDefinition;
+
+        /** Source Map of Type Sections */
+        SourceMap<mson::TypeSections> sections;
+
+        /** Check if empty */
+        bool empty() const;
+    };
+
+    /** Source Map structure for Property Member */
+    template<>
+    struct SourceMap<mson::PropertyMember> : public SourceMap<mson::ValueMember> {
+
+        /** Source Map for Property Name */
+        SourceMap<mson::PropertyName> name;
+
+        /** Check if empty */
+        bool empty() const;
+    };
+
+    /** Source Map structure for One Of */
+    // `OneOf` is the same as `Elements`
+
+    /** Source Map structure for Element */
+    template<>
+    struct SourceMap<mson::Element> : public SourceMapBase {
+
+        /** EITHER Source Map of Property Member */
+        SourceMap<mson::PropertyMember> property;
+
+        /** OR Source Map of Value Member */
+        SourceMap<mson::ValueMember> value;
+
+        /** OR Source Map of Mixin */
+        SourceMap<mson::Mixin> mixin;
+
+        /** OR Source Map of One Of */
+        SourceMap<mson::OneOf>& oneOf();
+        const SourceMap<mson::OneOf>& oneOf() const;
+
+        /** OR Source Map of Collection of elements */
+        SourceMap<mson::Elements>& elements();
+        const SourceMap<mson::Elements>& elements() const;
+
+        /** Builds the structure from group of elements */
+        SourceMap<mson::Element>& operator=(const SourceMap<mson::Elements>& rhs);
+
+        /** Constructor */
+        SourceMap();
+
+        /** Copy constructor */
+        SourceMap(const SourceMap<mson::Element>& rhs);
+
+        /** Assignment operator */
+        SourceMap<mson::Element>& operator=(const SourceMap<mson::Element>& rhs);
+
+        /** Destructor */
+        ~SourceMap();
+
+    private:
+        std::unique_ptr<SourceMap<mson::Elements> > m_elements;
+    };
+}
+
+#endif

data/ext/drafter/ext/snowcrash/src/MSONTypeSectionParser.cc

@@ -0,0 +1,209 @@
+//
+//  MSONTypeSectionParser.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/12/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "MSONOneOfParser.h"
+#include "MSONPropertyMemberParser.h"
+
+namespace snowcrash {
+
+    /** Implementation of processNestedSection */
+    MarkdownNodeIterator SectionProcessor<mson::TypeSection>::processNestedSection(const MarkdownNodeIterator& node,
+                                                                                   const MarkdownNodes& siblings,
+                                                                                   SectionParserData& pd,
+                                                                                   const ParseResultRef<mson::TypeSection>& out) {
+
+        MarkdownNodeIterator cur = node;
+        SectionType parentSectionType = pd.parentSectionContext();
+
+        mson::Element element;
+        SourceMap<mson::Element> elementSM;
+
+        if (node->type == mdp::HeaderMarkdownNodeType) {
+            return cur;
+        }
+
+        if (parentSectionType == MSONPropertyMembersSectionType ||
+            parentSectionType == MSONValueMembersSectionType) {
+
+            switch (pd.sectionContext()) {
+                case MSONMixinSectionType:
+                {
+                    IntermediateParseResult<mson::Mixin> mixin(out.report);
+                    cur = MSONMixinParser::parse(node, siblings, pd, mixin);
+
+                    element.build(mixin.node);
+
+                    if (pd.exportSourceMap()) {
+                        elementSM.mixin = mixin.sourceMap;
+                    }
+
+                    break;
+                }
+
+                case MSONOneOfSectionType:
+                {
+                    if (parentSectionType != MSONPropertyMembersSectionType) {
+
+                        // WARN: One of can not be a nested member for a non object structure type
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                        out.report.warnings.push_back(Warning("one-of can not be a nested member for a type not sub typed from object",
+                                                              LogicalErrorWarning,
+                                                              sourceMap));
+
+                        return cur;
+                    }
+
+                    IntermediateParseResult<mson::OneOf> oneOf(out.report);
+                    cur = MSONOneOfParser::parse(node, siblings, pd, oneOf);
+
+                    element.build(oneOf.node);
+
+                    if (pd.exportSourceMap()) {
+                        elementSM = oneOf.sourceMap;
+                    }
+
+                    break;
+                }
+
+                case MSONSectionType:
+                {
+                    if (parentSectionType == MSONPropertyMembersSectionType) {
+
+                        IntermediateParseResult<mson::PropertyMember> propertyMember(out.report);
+                        cur = MSONPropertyMemberParser::parse(node, siblings, pd, propertyMember);
+
+                        element.build(propertyMember.node);
+
+                        if (pd.exportSourceMap()) {
+                            elementSM.property = propertyMember.sourceMap;
+                        }
+                    }
+                    else {
+
+                        IntermediateParseResult<mson::ValueMember> valueMember(out.report);
+                        cur = MSONValueMemberParser::parse(node, siblings, pd, valueMember);
+
+                        element.build(valueMember.node);
+
+                        if (pd.exportSourceMap()) {
+                            elementSM.value = valueMember.sourceMap;
+                        }
+                    }
+
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+        else if (parentSectionType == MSONSampleDefaultSectionType) {
+
+            switch (pd.sectionContext()) {
+                case MSONMixinSectionType:
+                case MSONOneOfSectionType:
+                {
+                    // WARN: mixin and oneOf not supported in sample/default
+                    std::stringstream ss;
+
+                    ss << "sample and default type sections cannot have `" << SectionName(pd.sectionContext()) << "` type";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          LogicalErrorWarning,
+                                                          sourceMap));
+                    break;
+                }
+
+                case MSONSectionType:
+                {
+                    if ((out.node.baseType == mson::ValueBaseType ||
+                         out.node.baseType == mson::ImplicitValueBaseType) &&
+                        node->type == mdp::ListItemMarkdownNodeType) {
+
+                        IntermediateParseResult<mson::ValueMember> valueMember(out.report);
+                        cur = MSONValueMemberParser::parse(node, siblings, pd, valueMember);
+
+                        element.build(valueMember.node);
+
+                        if (pd.exportSourceMap()) {
+                            elementSM.value = valueMember.sourceMap;
+                        }
+                    }
+                    else if ((out.node.baseType == mson::ObjectBaseType ||
+                              out.node.baseType == mson::ImplicitObjectBaseType) &&
+                             node->type == mdp::ListItemMarkdownNodeType) {
+
+                        IntermediateParseResult<mson::PropertyMember> propertyMember(out.report);
+                        cur = MSONPropertyMemberParser::parse(node, siblings, pd, propertyMember);
+
+                        element.build(propertyMember.node);
+
+                        if (pd.exportSourceMap()) {
+                            elementSM.property = propertyMember.sourceMap;
+                        }
+                    }
+
+                    if (out.node.baseType == mson::PrimitiveBaseType ||
+                        out.node.baseType == mson::ImplicitPrimitiveBaseType) {
+
+                        if (!out.node.content.value.empty()) {
+                            TwoNewLines(out.node.content.value);
+                        }
+
+                        mdp::ByteBuffer content = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+                        out.node.content.value += content;
+
+                        if (pd.exportSourceMap() && !content.empty()) {
+                            out.sourceMap.value.sourceMap.append(node->sourceMap);
+                        }
+
+                        cur = ++MarkdownNodeIterator(node);
+                    }
+
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+
+        if (element.klass != mson::Element::UndefinedClass) {
+            out.node.content.elements().push_back(element);
+
+            if (pd.exportSourceMap()) {
+                out.sourceMap.elements().collection.push_back(elementSM);
+            }
+        }
+
+        return cur;
+    }
+
+    /** Implementation of nestedSectionType */
+    SectionType SectionProcessor<mson::TypeSection>::nestedSectionType(const MarkdownNodeIterator& node) {
+
+        SectionType nestedType = UndefinedSectionType;
+
+        // Check if mson mixin section
+        nestedType = SectionProcessor<mson::Mixin>::sectionType(node);
+
+        if (nestedType != UndefinedSectionType) {
+            return nestedType;
+        }
+
+        // Check if mson one of section
+        nestedType = SectionProcessor<mson::OneOf>::sectionType(node);
+
+        if (nestedType != UndefinedSectionType) {
+            return nestedType;
+        }
+
+        return MSONSectionType;
+    }
+}