redsnow 0.3.7 → 0.4.0

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

@@ -0,0 +1,213 @@
+//
+//  MSONTypeSectionParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 11/4/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONTYPESECTIONPARSER_H
+#define SNOWCRASH_MSONTYPESECTIONPARSER_H
+
+#include "SectionParser.h"
+#include "MSONUtility.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** MSON Default Type Section matching regex */
+    const char* const MSONDefaultTypeSectionRegex = "^[[:blank:]]*[Dd]efault[[:blank:]]*(:.*)?$";
+
+    /** MSON Sample Type Section matching regex */
+    const char* const MSONSampleTypeSectionRegex = "^[[:blank:]]*[Ss]ample[[:blank:]]*(:.*)?$";
+
+    /** MSON Value Members Type Section matching regex */
+    const char* const MSONValueMembersTypeSectionRegex = "^[[:blank:]]*([Ii]tems|[Mm]embers)[[:blank:]]*$";
+
+    /** MSON Property Members Type Section matching regex */
+    const char* const MSONPropertyMembersTypeSectionRegex = "^[[:blank:]]*([Pp]roperties)[[:blank:]]*$";
+
+    /**
+     * MSON Type Section Section Processor
+     */
+    template<>
+    struct SectionProcessor<mson::TypeSection> : public SignatureSectionProcessorBase<mson::TypeSection> {
+
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits(SignatureTraits::IdentifierTrait |
+                                            SignatureTraits::ValuesTrait);
+
+            return signatureTraits;
+        }
+
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const ParseResultRef<mson::TypeSection>& out) {
+
+            bool assignValues = false;
+
+            if (IEqual<std::string>()(signature.identifier, "Default")) {
+
+                out.node.klass = mson::TypeSection::DefaultClass;
+                assignValues = true;
+            }
+            else if (IEqual<std::string>()(signature.identifier, "Sample")) {
+
+                out.node.klass = mson::TypeSection::SampleClass;
+                assignValues = true;
+            }
+            else if (IEqual<std::string>()(signature.identifier, "Items") ||
+                     IEqual<std::string>()(signature.identifier, "Members")) {
+
+                if (out.node.baseType != mson::ValueBaseType &&
+                    out.node.baseType != mson::ImplicitValueBaseType) {
+
+                    //WARN: Items/Members should only be allowed for value types
+                    std::stringstream ss;
+
+                    ss << "type section `" << signature.identifier;
+                    ss << "` not allowed for a type sub-typed from a primitive or object type";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          LogicalErrorWarning,
+                                                          sourceMap));
+
+                    return node;
+                }
+
+                out.node.klass = mson::TypeSection::MemberTypeClass;
+            }
+            else if (IEqual<std::string>()(signature.identifier, "Properties")) {
+
+                if (out.node.baseType != mson::ObjectBaseType &&
+                    out.node.baseType != mson::ImplicitObjectBaseType) {
+
+                    //WARN: Properties should only be allowed for object types
+                    std::stringstream ss;
+
+                    ss << "type section `" << signature.identifier;
+                    ss << "` is only allowed for a type sub-typed from an object type";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          LogicalErrorWarning,
+                                                          sourceMap));
+
+                    return node;
+                }
+
+                out.node.klass = mson::TypeSection::MemberTypeClass;
+            }
+
+            if (assignValues &&
+                (!signature.values.empty() || !signature.value.empty())) {
+
+                if (out.node.baseType == mson::PrimitiveBaseType ||
+                    out.node.baseType == mson::ImplicitPrimitiveBaseType) {
+
+                    out.node.content.value = signature.value;
+
+                    if (pd.exportSourceMap()) {
+                        out.sourceMap.value.sourceMap = node->sourceMap;
+                    }
+                }
+                else if (out.node.baseType == mson::ValueBaseType ||
+                         out.node.baseType == mson::ImplicitValueBaseType) {
+
+                    for (size_t i = 0; i < signature.values.size(); i++) {
+
+                        mson::Element element;
+                        SourceMap<mson::Element> elementSM;
+
+                        element.build(mson::parseValue(signature.values[i]));
+                        out.node.content.elements().push_back(element);
+
+                        if (pd.exportSourceMap()) {
+
+                            elementSM.value.valueDefinition.sourceMap = node->sourceMap;
+                            out.sourceMap.elements().collection.push_back(elementSM);
+                        }
+                    }
+                }
+                else if (out.node.baseType == mson::ObjectBaseType ||
+                         out.node.baseType == mson::ImplicitObjectBaseType) {
+
+                    // WARN: sample/default is for an object but it has values in signature
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    out.report.warnings.push_back(Warning("a sample and/or default type section for a type which is sub-typed from an object cannot have value(s) beside the keyword",
+                                                          LogicalErrorWarning,
+                                                          sourceMap));
+                }
+            }
+
+            if (assignValues && !signature.remainingContent.empty() &&
+                (out.node.baseType == mson::PrimitiveBaseType ||
+                 out.node.baseType == mson::ImplicitPrimitiveBaseType)) {
+
+                out.node.content.value += signature.remainingContent;
+
+                if (pd.exportSourceMap()) {
+                    out.sourceMap.value.sourceMap.append(node->sourceMap);
+                }
+            }
+
+            return ++MarkdownNodeIterator(node);
+        }
+
+        NO_SECTION_DESCRIPTION(mson::TypeSection)
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator&,
+                                                         const MarkdownNodes&,
+                                                         SectionParserData&,
+                                                         const ParseResultRef<mson::TypeSection>&);
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            mdp::ByteBuffer subject, remaining;
+
+            if (node->type == mdp::HeaderMarkdownNodeType &&
+                !node->text.empty()) {
+
+                subject = node->text;
+            }
+            else if (node->type == mdp::ListItemMarkdownNodeType &&
+                     !node->children().empty()) {
+
+                subject = node->children().front().text;
+            }
+
+            subject = GetFirstLine(subject, remaining);
+            TrimString(subject);
+
+            if (RegexMatch(subject, MSONDefaultTypeSectionRegex) ||
+                RegexMatch(subject, MSONSampleTypeSectionRegex)) {
+
+                return MSONSampleDefaultSectionType;
+            }
+
+            if (RegexMatch(subject, MSONValueMembersTypeSectionRegex)) {
+                return MSONValueMembersSectionType;
+            }
+
+            if (RegexMatch(subject, MSONPropertyMembersTypeSectionRegex)) {
+                return MSONPropertyMembersSectionType;
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator&);
+    };
+
+    /** MSON Type Section (Header) Section Parser */
+    typedef SectionParser<mson::TypeSection, HeaderSectionAdapter> MSONTypeSectionHeaderParser;
+
+    /** MSON Type Section (List) Section Parser */
+    typedef SectionParser<mson::TypeSection, ListSectionAdapter> MSONTypeSectionListParser;
+}
+
+#endif

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

@@ -0,0 +1,423 @@
+//
+//  MSONUtility.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 10/23/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MSONUTILITY_H
+#define SNOWCRASH_MSONUTILITY_H
+
+#include "MSONSourcemap.h"
+
+using namespace scpl;
+
+namespace mson {
+
+    /**
+     * \brief Check if the given string is variable
+     *
+     * \param String to check
+     *
+     * \return True if variable string
+     */
+    inline bool checkVariable(const std::string& subject) {
+
+        std::string emphasisChars = mdp::MarkdownEmphasisChars;
+
+        if (emphasisChars.find(subject[0]) != std::string::npos &&
+            subject[0] == subject[subject.length() - 1]) {
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * \brief Parse a MSON BaseTypeName into MSON BaseType
+     *
+     * \param type MSON BaseTypeName
+     *
+     * \return MSON BaseType
+     */
+    inline BaseType parseBaseType(const BaseTypeName& type) {
+
+        if ((type == StringTypeName) ||
+            (type == NumberTypeName) ||
+            (type == BooleanTypeName)) {
+
+            return PrimitiveBaseType;
+        }
+
+        if (type == ObjectTypeName) {
+            return ObjectBaseType;
+        }
+
+        if ((type == ArrayTypeName) ||
+            (type == EnumTypeName)) {
+
+            return ValueBaseType;
+        }
+
+        return UndefinedBaseType;
+    }
+
+    /**
+     * \brief Parse a string into MSON Value structure
+     *
+     * \param subject String which represents the value
+     *
+     * \return MSON Value
+     */
+    inline Value parseValue(const std::string& subject) {
+
+        Value value;
+        std::string buffer = subject;
+
+        if (checkVariable(subject)) {
+
+            std::string escapedString = snowcrash::RetrieveEscaped(buffer, 0, true);
+
+            value.literal = escapedString;
+            value.variable = true;
+        }
+
+        if (value.literal.empty()) {
+            value.literal = buffer;
+        }
+
+        // When the value is a wildcard
+        if (value.literal == "*") {
+
+            value.literal = "";
+            value.variable = true;
+        }
+
+        return value;
+    }
+
+    /**
+     * \brief Parse Symbol from a string
+     *
+     * \param subject String which represents the symbol
+     *
+     * \return MSON Symbol
+     */
+    inline Symbol parseSymbol(const std::string& subject) {
+
+        Symbol symbol;
+        Value value = parseValue(subject);
+
+        symbol.literal = value.literal;
+        symbol.variable = value.variable;
+
+        return symbol;
+    }
+
+    /**
+     * \brief Parse Type Name from a string
+     *
+     * \param subject String which represents the type name
+     * \param typeName MSON Type Name
+     */
+    inline void parseTypeName(const std::string& subject,
+                              TypeName& typeName) {
+
+        if (subject == "boolean") {
+            typeName.base = BooleanTypeName;
+        }
+        else if (subject == "string") {
+            typeName.base = StringTypeName;
+        }
+        else if (subject == "number") {
+            typeName.base = NumberTypeName;
+        }
+        else if (subject == "array") {
+            typeName.base = ArrayTypeName;
+        }
+        else if (subject == "enum") {
+            typeName.base = EnumTypeName;
+        }
+        else if (subject == "object") {
+            typeName.base = ObjectTypeName;
+        }
+        else {
+            typeName.symbol = parseSymbol(subject);
+        }
+    }
+
+    /**
+     * \brief Check Type Attribute from a string and fill list of type attributes accordingly
+     *
+     * \param attribute String that needs to be checked for attribute
+     * \param typeAttributes List of type attributes
+     *
+     * \return True if the given string is a type attribute
+     */
+    inline bool parseTypeAttribute(const std::string& attribute,
+                                   TypeAttributes& typeAttributes) {
+
+        bool isAttribute = true;
+
+        if (attribute == "required") {
+            typeAttributes |= RequiredTypeAttribute;
+        }
+        else if (attribute == "optional") {
+            typeAttributes |= OptionalTypeAttribute;
+        }
+        else if (attribute == "fixed") {
+            typeAttributes |= FixedTypeAttribute;
+        }
+        else if (attribute == "sample") {
+            typeAttributes |= SampleTypeAttribute;
+        }
+        else if (attribute == "default") {
+            typeAttributes |= DefaultTypeAttribute;
+        }
+        else {
+            isAttribute = false;
+        }
+
+        return isAttribute;
+    }
+
+    /**
+     * \brief Parse Type Specification from a signature attribute
+     *
+     * \param subject Attribute string representing the type specification
+     * \param typeSpecification MSON Type Specification
+     */
+    inline void parseTypeSpecification(const std::string& attribute,
+                                       TypeSpecification& typeSpecification) {
+
+        std::string subject = snowcrash::StripMarkdownLink(attribute);
+
+        bool lookingAtNested = false;    // If true, we are looking at nested types
+        bool lookingForEndLink = false;  // If true, we detected a link text and are looking for the end of it
+        bool alreadyParsedLink = false;  // If true, we already parsed the link text in the link
+
+        bool trimSubject = false;
+
+        size_t i = 0;
+        std::string buffer;
+
+        while (i < subject.length()) {
+
+            if (subject[i] == mdp::MarkdownBeginReference &&
+                !alreadyParsedLink) {
+
+                trimSubject = true;
+
+                if (!lookingAtNested) {
+
+                    snowcrash::TrimString(buffer);
+
+                    if (!buffer.empty()) {
+                        parseTypeName(buffer, typeSpecification.name);
+                    }
+
+                    lookingAtNested = true;
+                }
+                else {
+                    lookingForEndLink = true;
+                }
+            }
+            else if (subject[i] == mdp::MarkdownEndReference &&
+                     lookingAtNested &&
+                     lookingForEndLink) {
+
+                trimSubject = true;
+
+                TypeName typeName;
+                snowcrash::TrimString(buffer);
+
+                if (!buffer.empty()) {
+
+                    parseTypeName(buffer, typeName);
+                    typeSpecification.nestedTypes.push_back(typeName);
+                }
+
+                alreadyParsedLink = true;
+                lookingForEndLink = false;
+            }
+            else if (subject[i] == AttributeDelimiter &&
+                     lookingAtNested &&
+                     !lookingForEndLink) {
+
+                trimSubject = true;
+
+                if (alreadyParsedLink) {
+                    alreadyParsedLink = false;
+                }
+                else {
+
+                    TypeName typeName;
+                    snowcrash::TrimString(buffer);
+
+                    if (!buffer.empty()) {
+
+                        parseTypeName(buffer, typeName);
+                        typeSpecification.nestedTypes.push_back(typeName);
+                    }
+                }
+            }
+            else {
+
+                buffer += subject[i];
+                i++;
+            }
+
+            // Strip the subject until the current index
+            if (trimSubject) {
+
+                subject = subject.substr(i + 1);
+                snowcrash::TrimString(subject);
+
+                trimSubject = false;
+                buffer.clear();
+                i = 0;
+            }
+        }
+
+        snowcrash::TrimString(buffer);
+
+        if (buffer.empty() || alreadyParsedLink) {
+            return;
+        }
+
+        // Remove the ending square bracket
+        if (lookingAtNested &&
+            buffer[buffer.length() - 1] == mdp::MarkdownEndReference) {
+
+            buffer = buffer.substr(0, buffer.length() - 1);
+        }
+
+        TypeName typeName;
+
+        snowcrash::TrimString(buffer);
+        parseTypeName(buffer, typeName);
+
+        if (lookingAtNested) {
+            typeSpecification.nestedTypes.push_back(typeName);
+        }
+        else {
+            typeSpecification.name = typeName;
+        }
+    }
+
+    /**
+     * \brief Parse Type Definition from a list of signature attributes
+     *
+     * \param node Markdown node of the signature
+     * \param pd Section parser data
+     * \param attributes List of signature attributes
+     * \param report Parse result report
+     * \param typeDefinition MSON Type Definition
+     */
+    inline void parseTypeDefinition(const mdp::MarkdownNodeIterator& node,
+                                    snowcrash::SectionParserData& pd,
+                                    const std::vector<std::string>& attributes,
+                                    snowcrash::Report& report,
+                                    mson::TypeDefinition& typeDefinition) {
+
+        bool foundTypeSpecification = false;
+
+        for (std::vector<std::string>::const_iterator it = attributes.begin();
+             it != attributes.end();
+             it++) {
+
+            // If not a recognized type attribute
+            if (!parseTypeAttribute(*it, typeDefinition.attributes)) {
+
+                // If type specification is already found
+                if (foundTypeSpecification) {
+
+                    // WARN: Ignoring unrecognized type attribute
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.warnings.push_back(snowcrash::Warning("ignoring unrecognized type attribute",
+                                                                 snowcrash::IgnoringWarning,
+                                                                 sourceMap));
+                }
+                else {
+
+                    foundTypeSpecification = true;
+                    parseTypeSpecification(*it, typeDefinition.typeSpecification);
+                }
+            }
+        }
+
+        typeDefinition.baseType = parseBaseType(typeDefinition.typeSpecification.name.base);
+        NamedTypeBaseTable::iterator it = pd.namedTypeBaseTable.find(typeDefinition.typeSpecification.name.symbol.literal);
+
+        if (typeDefinition.baseType == UndefinedBaseType &&
+            it != pd.namedTypeBaseTable.end()) {
+
+            typeDefinition.baseType = it->second;
+        }
+
+        if (typeDefinition.baseType == UndefinedBaseType &&
+            !typeDefinition.typeSpecification.name.symbol.literal.empty()) {
+
+            // WARN: Unable to find the named type in the named type base type table
+            std::stringstream ss;
+            ss << "unable to find the symbol `" << typeDefinition.typeSpecification.name.symbol.literal << "` in the list of named types";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.warnings.push_back(snowcrash::Warning(ss.str(),
+                                                         snowcrash::LogicalErrorWarning,
+                                                         sourceMap));
+        }
+
+        if (typeDefinition.baseType != ValueBaseType &&
+            typeDefinition.baseType != ImplicitValueBaseType &&
+            !typeDefinition.typeSpecification.nestedTypes.empty()) {
+
+            // WARN: Nested types for non (array or enum) structure base type
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.warnings.push_back(snowcrash::Warning("nested types should be present only for types which are sub typed from either array or enum structure type",
+                                                         snowcrash::LogicalErrorWarning,
+                                                         sourceMap));
+        }
+    }
+
+    /**
+     * \brief Parse Property Name from a string given by signature identifier
+     *
+     * \param node Markdown node of the signature
+     * \param pd Section parser data
+     * \param subject String representing the property name
+     * \param report Parse result report
+     * \param propertyName MSON Property Name
+     */
+    inline void parsePropertyName(const mdp::MarkdownNodeIterator& node,
+                                  snowcrash::SectionParserData& pd,
+                                  const std::string& subject,
+                                  snowcrash::Report& report,
+                                  PropertyName& propertyName) {
+
+        std::string buffer = subject;
+
+        if (checkVariable(subject)) {
+
+            std::string escapedString = snowcrash::RetrieveEscaped(buffer, 0, true);
+
+            SignatureTraits traits(SignatureTraits::ValuesTrait |
+                                   SignatureTraits::AttributesTrait);
+
+            Signature signature = SignatureSectionProcessorBase<PropertyName>::parseSignature(node, pd, traits, report, escapedString);
+
+            if (!signature.value.empty()) {
+                propertyName.variable.values.push_back(parseValue(signature.value));
+            }
+
+            parseTypeDefinition(node, pd, signature.attributes, report, propertyName.variable.typeDefinition);
+        }
+        else {
+            propertyName.literal = subject;
+        }
+    }
+}
+
+#endif