redsnow 0.3.7 → 0.4.0

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

@@ -0,0 +1,108 @@
+//
+//  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 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);
+            mson::parseTypeDefinition(node, pd, signature.attributes, out.report, out.node.typeDefinition);
+
+            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;
+            }
+
+            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);
+        }
+    };
+
+    /** 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.sourceData);
+                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,232 @@
+//
+//  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 {
+
+    /* We only allow at the maximum 2 attributes for new syntax parameters */
+    const size_t MAX_ATTRIBUTES = 2;
+
+    /* Type wrapped by enum matching regex */
+    const char* const EnumRegex = "^enum\\[([^][]+)]$";
+
+    /**
+     * 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";
+            }
+
+            parseAttributes(node, pd, signature.attributes, out);
+
+            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()) {
+                        out.node.defaultValue = typeSection.node.content.value;
+
+                        if (pd.exportSourceMap()) {
+                            out.sourceMap.defaultValue.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);
+
+            if ((!out.node.exampleValue.empty() || !out.node.defaultValue.empty()) &&
+                !out.node.values.empty()) {
+
+                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;
+        }
+
+        static void parseAttributes(const MarkdownNodeIterator& node,
+                                    SectionParserData& pd,
+                                    const std::vector<mdp::ByteBuffer>& attributes,
+                                    const ParseResultRef<MSONParameter>& out) {
+
+            out.node.use = UndefinedParameterUse;
+
+            if (attributes.size() <= MAX_ATTRIBUTES) {
+                size_t i = 0;
+                bool definedUse = false;
+
+                // Traverse over parameter's traits
+                while (i < attributes.size()) {
+                    if (attributes[i] == "optional" && !definedUse) {
+                        out.node.use = OptionalParameterUse;
+                        definedUse = true;
+                    }
+                    else if (attributes[i] == "required" && !definedUse) {
+                        out.node.use = RequiredParameterUse;
+                        definedUse = true;
+                    }
+                    else {
+
+                        // Retrieve the type which is wrapped by enum[]
+                        std::string typeInsideEnum = RegexCaptureFirst(attributes[i], EnumRegex);
+                        TrimString(typeInsideEnum);
+
+                        if (!typeInsideEnum.empty()) {
+                            out.node.type = typeInsideEnum;
+                        }
+                        else {
+                            out.node.type = attributes[i];
+                        }
+                    }
+
+                    i++;
+                }
+
+                if (pd.exportSourceMap()) {
+                    if (!out.node.type.empty()) {
+                        out.sourceMap.type.sourceMap = node->sourceMap;
+                    }
+
+                    if (definedUse) {
+                        out.sourceMap.use.sourceMap = node->sourceMap;
+                    }
+                }
+            }
+            else {
+                // WARN: Additional parameters traits warning
+                std::stringstream ss;
+
+                ss << "unable to parse additional parameter traits";
+                ss << ", expected '([required | optional], [<type> | enum[<type>])'";
+                ss << ", e.g. '(optional, string)'";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                out.report.warnings.push_back(Warning(ss.str(),
+                                                      FormattingWarning,
+                                                      sourceMap));
+            }
+        }
+    };
+
+    /** MSON Parameter Section Parser */
+    typedef SectionParser<MSONParameter, ListSectionAdapter> MSONParameterParser;
+}
+
+#endif