lounge_lizard 0.1.0

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

@@ -0,0 +1,103 @@
+//
+//  MSONMixinParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/5/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONMIXINPARSER_H
+#define SNOWCRASH_MSONMIXINPARSER_H
+
+#include "SectionParser.h"
+#include "MSONUtility.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** MSON Mixin matching regex */
+    const char* const MSONMixinRegex = "^[[:blank:]]*([Ii]nclude[[:blank:]]+)";
+
+    /**
+     * MSON Mixin Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::Mixin> : public SignatureSectionProcessorBase<mson::Mixin> {
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait |
+                                            SignatureTraits::AttributesTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<mson::Mixin>& out) {
+
+            CaptureGroups captureGroups;
+            std::vector<mdp::ByteBuffer> attributes = signature.attributes;
+
+            if (RegexCapture(signature.identifier, MSONMixinRegex, captureGroups, 2) &&
+                !captureGroups[1].empty()) {
+
+                // Get the type name and insert it into attributes
+                std::string typeName = signature.identifier.substr(captureGroups[1].length());
+                attributes.insert(attributes.begin(), typeName);
+            }
+
+            mson::parseTypeDefinition(node, pd, attributes, out.report, out.node);
+
+            if (pd.exportSourceMap()) {
+                out.sourceMap.sourceMap = node->sourceMap;
+            }
+
+            if ((out.node.baseType == mson::PrimitiveBaseType) ||
+                (out.node.baseType == mson::UndefinedBaseType)) {
+
+                // WARN: invalid mixin base type
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning("mixin type may not include a type of a primitive sub-type",
+                                                      FormattingWarning,
+                                                      sourceMap));
+            }
+
+            // Check circular references
+            if (out.node.typeSpecification.name.base == mson::UndefinedTypeName &&
+                !out.node.typeSpecification.name.symbol.literal.empty() &&
+                !out.node.typeSpecification.name.symbol.variable) {
+
+                mson::addDependency(node, pd, out.node.typeSpecification.name.symbol.literal, pd.namedTypeContext, out.report, true);
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        NO_SECTION_DESCRIPTION(mson::Mixin)
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                mdp::ByteBuffer subject = node->children().front().text;
+
+                TrimString(subject);
+
+                if (RegexMatch(subject, MSONMixinRegex)) {
+                    return MSONMixinSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+    };
+
+    /** MSON Mixin Section Parser */
+    typedef SectionParser<mson::Mixin, ListSectionAdapter> MSONMixinParser;
+}
+
+#endif

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

@@ -0,0 +1,135 @@
+//
+//  MSONNamedTypeParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/5/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONNAMEDTYPEPARSER_H
+#define SNOWCRASH_MSONNAMEDTYPEPARSER_H
+
+#include "MSONValueMemberParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** MSON reserved characters matching regex */
+    const char* const MSONReservedCharsRegex = "[]:\()<>\{}[_*+`-]+";
+
+    /**
+     * MSON Named Type Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::NamedType> : public SignatureSectionProcessorBase<mson::NamedType> {
+
+        static SignatureTraits signatureTraits() {
+
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait |
+                                            SignatureTraits::AttributesTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<mson::NamedType>& out) {
+
+            mson::parseTypeName(signature.identifier, out.node.name, false);
+            mson::parseTypeDefinition(node, pd, signature.attributes, out.report, out.node.typeDefinition);
+
+            mdp::ByteBuffer subject = node->text;
+            TrimString(subject);
+
+            if (subject[0] != '`' && RegexMatch(out.node.name.symbol.literal, MSONReservedCharsRegex)) {
+
+                // WARN: named type name should not contain reserved characters
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning("please escape the name of the data structure using backticks since it contains MSON reserved characters",
+                                                      FormattingWarning,
+                                                      sourceMap));
+            }
+
+            if (pd.exportSourceMap()) {
+
+                if (!out.node.name.empty()) {
+                    out.sourceMap.name.sourceMap = node->sourceMap;
+                }
+
+                if (!out.node.typeDefinition.empty()) {
+                    out.sourceMap.typeDefinition.sourceMap = node->sourceMap;
+                }
+            }
+
+            // Named types should have type specification when sub-typed from primitive types
+            if (out.node.typeDefinition.baseType == mson::UndefinedBaseType) {
+                out.node.typeDefinition.baseType = mson::ImplicitObjectBaseType;
+            }
+
+            // Setup named type context
+            pd.namedTypeContext = out.node.name.symbol.literal;
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<mson::NamedType>& 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::NamedType>& out) {
+
+            ParseResultRef<mson::TypeSections> typeSections(out.report, out.node.sections, out.sourceMap.sections);
+
+            return SectionProcessor<mson::ValueMember>
+                    ::processNestedMembers<MSONTypeSectionHeaderParser>(node, siblings, pd, typeSections,
+                                                                        out.node.typeDefinition.baseType);
+        }
+
+        static bool isDescriptionNode(const MarkdownNodeIterator& node,
+                                      SectionType sectionType) {
+
+            return SectionProcessor<mson::ValueMember>::isDescriptionNode(node, sectionType);
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            SectionType sectionType = SectionKeywordSignature(node);
+
+            if (node->type == mdp::HeaderMarkdownNodeType &&
+                sectionType == UndefinedSectionType) {
+
+                return MSONNamedTypeSectionType;
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            return SectionProcessor<mson::ValueMember>::nestedSectionType(node);
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<mson::NamedType>& out) {
+
+            // Clear named type context
+            pd.namedTypeContext.clear();
+        }
+    };
+
+    /** MSON Named Type Section Parser */
+    typedef SectionParser<mson::NamedType, HeaderSectionAdapter> MSONNamedTypeParser;
+}
+
+#endif

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

@@ -0,0 +1,132 @@
+//
+//  MSONOneOfParser.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/12/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "MSONOneOfParser.h"
+#include "MSONTypeSectionParser.h"
+#include "MSONPropertyMemberParser.h"
+
+namespace snowcrash {
+
+    /** Implementation of processNestedSection */
+    MarkdownNodeIterator SectionProcessor<mson::OneOf>::processNestedSection(const MarkdownNodeIterator& node,
+                                                                             const MarkdownNodes& siblings,
+                                                                             SectionParserData& pd,
+                                                                             const ParseResultRef<mson::OneOf>& out) {
+
+        MarkdownNodeIterator cur = node;
+        mson::Element element;
+        SourceMap<mson::Element> elementSM;
+
+        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:
+            {
+                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 MSONPropertyMembersSectionType:
+            {
+                IntermediateParseResult<mson::TypeSection> typeSection(out.report);
+                typeSection.node.baseType = mson::ObjectBaseType;
+
+                cur = MSONTypeSectionListParser::parse(node, siblings, pd, typeSection);
+
+                element.buildFromElements(typeSection.node.content.elements());
+
+                if (pd.exportSourceMap()) {
+                    elementSM = typeSection.sourceMap.elements();
+                }
+
+                break;
+            }
+
+            case MSONPropertyMemberSectionType:
+            {
+                IntermediateParseResult<mson::PropertyMember> propertyMember(out.report);
+                cur = MSONPropertyMemberParser::parse(node, siblings, pd, propertyMember);
+
+                element.build(propertyMember.node);
+
+                if (pd.exportSourceMap()) {
+                    elementSM.property = propertyMember.sourceMap;
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        if (element.klass != mson::Element::UndefinedClass) {
+            out.node.push_back(element);
+
+            if (pd.exportSourceMap()) {
+                out.sourceMap.collection.push_back(elementSM);
+            }
+        }
+
+        return cur;
+    }
+
+    /** Implementation of nestedSectionType */
+    SectionType SectionProcessor<mson::OneOf>::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;
+        }
+
+        // Check if mson member type section section
+        nestedType = SectionProcessor<mson::TypeSection>::sectionType(node);
+
+        if (nestedType != UndefinedSectionType) {
+            return nestedType;
+        }
+
+        // Return property member type section if list item
+        if (node->type == mdp::ListItemMarkdownNodeType) {
+            return MSONPropertyMemberSectionType;
+        }
+
+        return UndefinedSectionType;
+    }
+}

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

@@ -0,0 +1,80 @@
+//
+//  MSONOneOfParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/5/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONONEOFPARSER_H
+#define SNOWCRASH_MSONONEOFPARSER_H
+
+#include "MSONMixinParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** MSON One Of matching regex */
+    const char* const MSONOneOfRegex = "^[[:blank:]]*[Oo]ne[[:blank:]]+[Oo]f[[:blank:]]*$";
+
+    /**
+     * MSON One Of Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::OneOf> : public SignatureSectionProcessorBase<mson::OneOf> {
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait);
+
+            return signatureTraits;
+        }
+
+        NO_SECTION_DESCRIPTION(mson::OneOf)
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator&,
+                                                         const MarkdownNodes&,
+                                                         SectionParserData&,
+                                                         const ParseResultRef<mson::OneOf>&);
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<mson::OneOf>& out) {
+
+            if (out.node.empty()) {
+
+                // WARN: one of type do not have nested members
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceCharacterIndex);
+                out.report.warnings.push_back(Warning("one of type must have nested members",
+                                                      EmptyDefinitionWarning,
+                                                      sourceMap));
+            }
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::ListItemMarkdownNodeType
+                && !node->children().empty()) {
+
+                mdp::ByteBuffer remaining, subject = node->children().front().text;
+
+                subject = GetFirstLine(subject, remaining);
+                TrimString(subject);
+
+                if (RegexMatch(subject, MSONOneOfRegex)) {
+                    return MSONOneOfSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator&);
+    };
+
+    /** MSON One Of Section Parser */
+    typedef SectionParser<mson::OneOf, ListSectionAdapter> MSONOneOfParser;
+}
+
+#endif

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

@@ -0,0 +1,166 @@
+//
+//  MSONParameterParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 12/03/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONPARAMETERPARSER_H
+#define SNOWCRASH_MSONPARAMETERPARSER_H
+
+#include "ParameterParser.h"
+#include "MSONValueMemberParser.h"
+#include "MSONTypeSectionParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /**
+     * MSON Parameter Section Processor
+     */
+    template<>
+    struct SectionProcessor<MSONParameter> : public SignatureSectionProcessorBase<MSONParameter> {
+
+        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<MSONParameter>& out) {
+
+            out.node.name = signature.identifier;
+            out.node.description = signature.content;
+            out.node.exampleValue = signature.value;
+
+            if (!signature.remainingContent.empty()) {
+                out.node.description += "\n" + signature.remainingContent + "\n";
+            }
+
+            SectionProcessor<Parameter>::parseAttributes(node, pd, signature.attributes, out, false);
+
+            if (pd.exportSourceMap()) {
+                if (!out.node.name.empty()) {
+                    out.sourceMap.name.sourceMap = node->sourceMap;
+                }
+
+                if (!out.node.description.empty()) {
+                    out.sourceMap.description.sourceMap = node->sourceMap;
+                }
+
+                if (!out.node.exampleValue.empty()) {
+                    out.sourceMap.exampleValue.sourceMap = node->sourceMap;
+                }
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<MSONParameter>& out) {
+
+            SectionType sectionType = pd.sectionContext();
+            MarkdownNodeIterator cur = node;
+            IntermediateParseResult<mson::TypeSection> typeSection(out.report);
+
+            switch (sectionType) {
+                case MSONSampleDefaultSectionType:
+                {
+                    typeSection.node.baseType = mson::ImplicitPrimitiveBaseType;
+                    cur = MSONTypeSectionListParser::parse(node, siblings, pd, typeSection);
+
+                    if (typeSection.node.content.value.empty()) {
+                        break;
+                    }
+
+                    if (typeSection.node.klass == mson::TypeSection::DefaultClass) {
+                        out.node.defaultValue = typeSection.node.content.value;
+
+                        if (pd.exportSourceMap()) {
+                            out.sourceMap.defaultValue.sourceMap = typeSection.sourceMap.value.sourceMap;
+                        }
+                    }
+                    else if (typeSection.node.klass == mson::TypeSection::SampleClass) {
+                        out.node.exampleValue = typeSection.node.content.value;
+                        out.sourceMap.exampleValue.sourceMap = typeSection.sourceMap.value.sourceMap;
+                    }
+
+                    break;
+                }
+
+                case MSONValueMembersSectionType:
+                {
+                    typeSection.node.baseType = mson::ImplicitValueBaseType;
+                    cur = MSONTypeSectionListParser::parse(node, siblings, pd, typeSection);
+
+                    out.node.values.clear();
+
+                    if (pd.exportSourceMap()) {
+                        out.sourceMap.values.collection.clear();
+                    }
+
+                    for (size_t i = 0; i < typeSection.node.content.elements().size(); i++) {
+                        mson::ValueMember valueMember = typeSection.node.content.elements().at(i).content.value;
+                        SourceMap<mson::ValueMember> valueMemberSM;
+
+                        if (pd.exportSourceMap()) {
+                            valueMemberSM = typeSection.sourceMap.elements().collection.at(i).value;
+                        }
+
+                        if (valueMember.valueDefinition.values.size() == 1) {
+                            out.node.values.push_back(valueMember.valueDefinition.values[0].literal);
+
+                            if (pd.exportSourceMap()) {
+                                SourceMap<Value> valueSM;
+                                valueSM.sourceMap = valueMemberSM.valueDefinition.sourceMap;
+
+                                out.sourceMap.values.collection.push_back(valueSM);
+                            }
+                        }
+                    }
+
+                    break;
+                }
+
+                default:
+                    break;
+            }
+
+            return cur;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<MSONParameter>& out) {
+
+            SectionProcessor<Parameter>::checkDefaultAndRequiredClash<MSONParameter>(node, pd, out);
+            SectionProcessor<Parameter>::checkExampleAndDefaultValue<MSONParameter>(node, pd, out);
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            SectionType nestedType = UndefinedSectionType;
+
+            // Recognize `Default` and `Members` sections
+            nestedType = SectionProcessor<mson::TypeSection>::sectionType(node);
+
+            return nestedType;
+        }
+    };
+
+    /** MSON Parameter Section Parser */
+    typedef SectionParser<MSONParameter, ListSectionAdapter> MSONParameterParser;
+}
+
+#endif