redsnow 0.3.7 → 0.4.0

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

@@ -0,0 +1,179 @@
+//
+//  MSONValueMemberParser.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/13/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#include "MSONOneOfParser.h"
+#include "MSONPropertyMemberParser.h"
+
+namespace snowcrash {
+
+    /** Implementation of nestedSectionType */
+    SectionType SectionProcessor<mson::ValueMember>::nestedSectionType(const MarkdownNodeIterator& node) {
+
+        SectionType nestedType = UndefinedSectionType;
+
+        // Check if mson type section section
+        nestedType = SectionProcessor<mson::TypeSection>::sectionType(node);
+
+        if (nestedType != UndefinedSectionType) {
+            return nestedType;
+        }
+
+        // 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;
+    }
+
+    /** Implementation of resolveAndProcessMSONSection */
+    MarkdownNodeIterator SectionProcessor<mson::ValueMember>::processMSONSection(const MarkdownNodeIterator& node,
+                                                                                 const MarkdownNodes& siblings,
+                                                                                 SectionParserData& pd,
+                                                                                 const ParseResultRef<mson::TypeSections>& sections,
+                                                                                 mson::BaseType& baseType) {
+
+        MarkdownNodeIterator cur = node;
+
+        // If we encounter a header node, stop parsing. Headers which are not
+        // type section signatures are ineligible to be nested sections of a MSON section
+        if (node->type == mdp::HeaderMarkdownNodeType) {
+            return cur;
+        }
+
+        // If the nodes follow after some block description without member
+        // seperator, then they are treated as description
+        if (!sections.node.empty() && sections.node.back().klass == mson::TypeSection::BlockDescriptionClass) {
+            return SectionProcessor<mson::ValueMember>::blockDescription(node, pd, sections.node, sections.sourceMap);
+        }
+
+        // Try to resolve base type if not given
+        resolveImplicitBaseType(node, pd.sectionContext(), baseType);
+
+        // Build a section to indicate nested members
+        if (sections.node.empty() ||
+            (!sections.node.empty() && sections.node.back().klass != mson::TypeSection::MemberTypeClass)) {
+
+            mson::TypeSection typeSection(mson::TypeSection::MemberTypeClass);
+
+            typeSection.baseType = baseType;
+            sections.node.push_back(typeSection);
+
+            if (pd.exportSourceMap()) {
+
+                SourceMap<mson::TypeSection> typeSectionSM;
+                sections.sourceMap.collection.push_back(typeSectionSM);
+            }
+        }
+
+        mson::Element element;
+        SourceMap<mson::Element> elementSM;
+
+        if (pd.sectionContext() == MSONMixinSectionType) {
+
+            IntermediateParseResult<mson::Mixin> mixin(sections.report);
+            cur = MSONMixinParser::parse(node, siblings, pd, mixin);
+
+            element.build(mixin.node);
+
+            if (pd.exportSourceMap()) {
+                elementSM.mixin = mixin.sourceMap;
+            }
+        }
+        else if (pd.sectionContext() == MSONOneOfSectionType) {
+
+            if (baseType != mson::ObjectBaseType &&
+                baseType != mson::ImplicitObjectBaseType) {
+
+                // WARN: One of can not be a nested member for a non object structure type
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                sections.report.warnings.push_back(Warning("one of may be a nested member of a object sub-types only",
+                                                           LogicalErrorWarning,
+                                                           sourceMap));
+
+                return cur;
+            }
+
+            IntermediateParseResult<mson::OneOf> oneOf(sections.report);
+            cur = MSONOneOfParser::parse(node, siblings, pd, oneOf);
+
+            element.build(oneOf.node);
+
+            if (pd.exportSourceMap()) {
+                elementSM = oneOf.sourceMap;
+            }
+        }
+        else {
+
+            if ((baseType == mson::ValueBaseType ||
+                 baseType == mson::ImplicitValueBaseType) &&
+                node->type == mdp::ListItemMarkdownNodeType) {
+
+                IntermediateParseResult<mson::ValueMember> valueMember(sections.report);
+                cur = MSONValueMemberParser::parse(node, siblings, pd, valueMember);
+
+                element.build(valueMember.node);
+
+                if (pd.exportSourceMap()) {
+                    elementSM.value = valueMember.sourceMap;
+                }
+            }
+            else if ((baseType == mson::ObjectBaseType ||
+                      baseType == mson::ImplicitObjectBaseType) &&
+                     node->type == mdp::ListItemMarkdownNodeType) {
+
+                IntermediateParseResult<mson::PropertyMember> propertyMember(sections.report);
+                cur = MSONPropertyMemberParser::parse(node, siblings, pd, propertyMember);
+
+                element.build(propertyMember.node);
+
+                if (pd.exportSourceMap()) {
+                    elementSM.property = propertyMember.sourceMap;
+                }
+            }
+            else if (baseType == mson::PrimitiveBaseType ||
+                     baseType == mson::ImplicitPrimitiveBaseType) {
+
+                // WARN: Primitive type members should not have nested members
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                sections.report.warnings.push_back(Warning("sub-types of primitive types should not have nested members",
+                                                           LogicalErrorWarning,
+                                                           sourceMap));
+            }
+            else {
+
+                // WARN: Ignoring unrecognized block in mson nested members
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                sections.report.warnings.push_back(Warning("ignorning unrecognized block",
+                                                           IgnoringWarning,
+                                                           sourceMap));
+
+                cur = ++MarkdownNodeIterator(node);
+            }
+        }
+
+        if (element.klass != mson::Element::UndefinedClass) {
+            sections.node.back().content.elements().push_back(element);
+
+            if (pd.exportSourceMap()) {
+                sections.sourceMap.collection.back().elements().collection.push_back(elementSM);
+            }
+        }
+
+        return cur;
+    }
+}

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

@@ -0,0 +1,346 @@
+//
+//  MSONValueMemberParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 10/22/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONVALUEMEMBERPARSER_H
+#define SNOWCRASH_MSONVALUEMEMBERPARSER_H
+
+#include "SectionParser.h"
+#include "MSONUtility.h"
+#include "MSONTypeSectionParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /**
+     * MSON Value Member Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::ValueMember> : public SignatureSectionProcessorBase<mson::ValueMember> {
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::ValuesTrait |
+                                            SignatureTraits::AttributesTrait |
+                                            SignatureTraits::ContentTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<mson::ValueMember>& out) {
+
+            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::ValueMember>& 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::ValueMember>& 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) {
+
+            if (SectionProcessor<mson::ValueMember>::nestedSectionType(node) != MSONSectionType ||
+                node->type == mdp::HeaderMarkdownNodeType) {
+
+                return false;
+            }
+
+            if (node->type != mdp::ListItemMarkdownNodeType) {
+                return true;
+            }
+
+            return SectionProcessorBase<mson::ValueMember>::isDescriptionNode(node, sectionType);
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator&);
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<mson::ValueMember>& out) {
+
+            SectionProcessor<mson::ValueMember>::finalizeImplicitBaseType(out.node.valueDefinition.typeDefinition.baseType);
+        }
+
+        /**
+         * \brief Use signature data to fill up the AST
+         *
+         * \param node Node to process
+         * \param pd Section Parser Data
+         * \param signature Signature data
+         * \param report Parse result report
+         * \param valueMember MSON Value Member
+         * \param sourceMap MSON Value Member source map
+         */
+        static MarkdownNodeIterator useSignatureData(const MarkdownNodeIterator& node,
+                                                     SectionParserData& pd,
+                                                     const Signature& signature,
+                                                     Report& report,
+                                                     mson::ValueMember& valueMember,
+                                                     SourceMap<mson::ValueMember>& sourceMap) {
+
+            valueMember.description = signature.content;
+
+            if (pd.exportSourceMap() && !signature.content.empty()) {
+                sourceMap.description.sourceMap = node->sourceMap;
+            }
+
+            mson::parseTypeDefinition(node, pd, signature.attributes, report, valueMember.valueDefinition.typeDefinition);
+            parseRemainingContent(node, pd, signature.remainingContent, valueMember.sections, sourceMap.sections);
+
+            if (signature.values.size() > 1) {
+
+                if (valueMember.valueDefinition.typeDefinition.baseType == mson::PrimitiveBaseType) {
+
+                    valueMember.valueDefinition.values.push_back(mson::parseValue(signature.value));
+
+                    if (pd.exportSourceMap()) {
+                        sourceMap.valueDefinition.sourceMap = node->sourceMap;
+                    }
+
+                    return ++MarkdownNodeIterator(node);
+                }
+                else if (valueMember.valueDefinition.typeDefinition.baseType == mson::UndefinedBaseType) {
+                    valueMember.valueDefinition.typeDefinition.baseType = mson::ImplicitValueBaseType;
+                }
+            }
+
+            for (std::vector<mdp::ByteBuffer>::const_iterator it = signature.values.begin();
+                 it != signature.values.end();
+                 it++) {
+
+                valueMember.valueDefinition.values.push_back(mson::parseValue(*it));
+            }
+
+            if (pd.exportSourceMap() && !valueMember.valueDefinition.empty()) {
+                sourceMap.valueDefinition.sourceMap = node->sourceMap;
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        /**
+         * \brief Parse the signature's remaining content
+         *
+         * \param node Node to process
+         * \param pd Section Parser Data
+         * \param remainingContent Signature's remaining content
+         * \param sections MSON Type Section collection
+         * \param sourceMap MSON Type Section collection source map
+         */
+        static void parseRemainingContent(const MarkdownNodeIterator& node,
+                                          SectionParserData& pd,
+                                          const mdp::ByteBuffer& remainingContent,
+                                          mson::TypeSections& sections,
+                                          SourceMap<mson::TypeSections>& sourceMap) {
+
+            if (remainingContent.empty()) {
+                return;
+            }
+
+            mson::TypeSection typeSection(mson::TypeSection::BlockDescriptionClass);
+
+            typeSection.content.description = remainingContent;
+            sections.push_back(typeSection);
+
+            if (pd.exportSourceMap()) {
+
+                SourceMap<mson::TypeSection> typeSectionSM;
+
+                typeSectionSM.description.sourceMap = node->sourceMap;
+                sourceMap.collection.push_back(typeSectionSM);
+            }
+        }
+
+        /**
+         * \brief Add block description to the mson member
+         *
+         * \param node Node to process
+         * \param pd Section Parser Data
+         * \param sections MSON Type Section collection
+         * \param sourceMap MSON Type Section collection source map
+         */
+        static MarkdownNodeIterator blockDescription(const MarkdownNodeIterator& node,
+                                                     SectionParserData& pd,
+                                                     mson::TypeSections& sections,
+                                                     SourceMap<mson::TypeSections>& sourceMap) {
+
+            if (sections.empty() ||
+                (sections.size() == 1 &&
+                 sections[0].klass == mson::TypeSection::BlockDescriptionClass)) {
+
+                if (sections.empty()) {
+
+                    mson::TypeSection typeSection(mson::TypeSection::BlockDescriptionClass);
+                    sections.push_back(typeSection);
+
+                    if (pd.exportSourceMap()) {
+
+                        SourceMap<mson::TypeSection> typeSectionSM;
+                        sourceMap.collection.push_back(typeSectionSM);
+                    }
+                }
+
+                if (!sections[0].content.description.empty()) {
+                    TwoNewLines(sections[0].content.description);
+                }
+
+                mdp::ByteBuffer content = mdp::MapBytesRangeSet(node->sourceMap, pd.sourceData);
+                sections[0].content.description += content;
+
+                if (pd.exportSourceMap() && !content.empty()) {
+                    sourceMap.collection[0].description.sourceMap.append(node->sourceMap);
+                }
+
+                return ++MarkdownNodeIterator(node);
+            }
+
+            return node;
+        }
+
+        /**
+         * \brief Process nested member types for a member (either property or value) and Named Type.
+         *
+         * \param node Node to process
+         * \param siblings Siblings of the node being processed
+         * \param pd Section Parser Data
+         * \param sections MSON Type Section collection Parse Result
+         * \param baseType Base Type of the MSON member to be sent for nested type sections
+         */
+        template<typename PARSER>
+        static MarkdownNodeIterator processNestedMembers(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<mson::TypeSections>& sections,
+                                                         mson::BaseType& baseType) {
+
+            MarkdownNodeIterator cur = node;
+
+            if (pd.sectionContext() == MSONSectionType ||
+                pd.sectionContext() == MSONMixinSectionType ||
+                pd.sectionContext() == MSONOneOfSectionType) {
+
+                cur = processMSONSection(node, siblings, pd, sections, baseType);
+            }
+            else {
+
+                // Try to resolve base type if not given before parsing further
+                resolveImplicitBaseType(node, pd.sectionContext(), baseType);
+
+                IntermediateParseResult<mson::TypeSection> typeSection(sections.report);
+                typeSection.node.baseType = baseType;
+
+                cur = PARSER::parse(node, siblings, pd, typeSection);
+
+                if (typeSection.node.klass != mson::TypeSection::UndefinedClass) {
+                    sections.node.push_back(typeSection.node);
+
+                    if (pd.exportSourceMap()) {
+                        sections.sourceMap.collection.push_back(typeSection.sourceMap);
+                    }
+                }
+            }
+
+            return cur;
+        }
+
+        /**
+         * \brief Given a MSONSectionType nested section, process it
+         *
+         * \param node Node to process
+         * \param siblings Siblings of the node being processed
+         * \param pd Section Parser Data
+         * \param sections MSON Type Section collection Parse Result
+         * \param baseType Base Type of the MSON member to be sent for nested type sections
+         */
+        static MarkdownNodeIterator processMSONSection(const MarkdownNodeIterator& node,
+                                                       const MarkdownNodes& siblings,
+                                                       SectionParserData& pd,
+                                                       const ParseResultRef<mson::TypeSections>& sections,
+                                                       mson::BaseType& baseType);
+
+        /**
+         * \brief If base type is still undefined, make it implicit string
+         *
+         * \param MSON member base type
+         */
+        static void finalizeImplicitBaseType(mson::BaseType& baseType) {
+
+            if (baseType == mson::UndefinedBaseType) {
+                baseType = mson::ImplicitPrimitiveBaseType;
+            }
+        }
+
+        /**
+         * \brief Resolve base types if possible, based on nested node given
+         *
+         * \param node Node to process
+         * \param sectionType Section Type
+         * \param baseType Base Type of the MSON member that needs to be resolved
+         */
+        static void resolveImplicitBaseType(const MarkdownNodeIterator& node,
+                                            const SectionType& sectionType,
+                                            mson::BaseType& baseType) {
+
+            if (baseType != mson::UndefinedBaseType) {
+                return;
+            }
+
+            switch (sectionType) {
+                case MSONSectionType:
+                case MSONOneOfSectionType:
+                case MSONMixinSectionType:
+                {
+                    if (node->type == mdp::ListItemMarkdownNodeType) {
+                        baseType = mson::ImplicitObjectBaseType;
+                    }
+
+                    break;
+                }
+
+                case MSONPropertyMembersSectionType:
+                {
+                    baseType = mson::ImplicitObjectBaseType;
+                    break;
+                }
+
+                case MSONSampleDefaultSectionType:
+                {
+                    baseType = mson::ImplicitPrimitiveBaseType;
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+    };
+
+    /** MSON Value Member Section Parser */
+    typedef SectionParser<mson::ValueMember, ListSectionAdapter> MSONValueMemberParser;
+}
+
+#endif