redsnow 0.3.7 → 0.4.0

data/ext/{snowcrash → drafter/ext/snowcrash}/src/Section.cc

@@ -36,6 +36,12 @@ std::string snowcrash::SectionName(const SectionType& section) {
         case HeadersSectionType:
             return "headers";
 
+        case MSONMixinSectionType:
+            return "mixin";
+
+        case MSONOneOfSectionType:
+            return "one of";
+
         default:
             return "section";
     }

data/ext/{snowcrash → drafter/ext/snowcrash}/src/Section.h

@@ -17,15 +17,18 @@ namespace snowcrash {
      *  API Blueprint Sections Types.
      */
     enum SectionType {
-        UndefinedSectionType,           /// < Undefined section
+        UndefinedSectionType = 0,       /// < Undefined section
         BlueprintSectionType,           /// < Blueprint overview
+        DataStructureGroupSectionType,  /// < Data Structure Group
         ResourceGroupSectionType,       /// < Resource group
         ResourceSectionType,            /// < Resource
         ActionSectionType,              /// < Action
+        RelationSectionType,            /// < Link Relation
         RequestSectionType,             /// < Request
         RequestBodySectionType,         /// < Request & Payload body combined (abbrev)
         ResponseSectionType,            /// < Response
         ResponseBodySectionType,        /// < Response & Body combined (abbrev)
+        AttributesSectionType,          /// < Attributes
         ModelSectionType,               /// < Model
         ModelBodySectionType,           /// < Model & Body combined (abbrev)
         BodySectionType,                /// < Payload Body
@@ -36,8 +39,18 @@ namespace snowcrash {
         ForeignSectionType,             /// < Foreign, unexpected section
         ParametersSectionType,          /// < Parameters
         ParameterSectionType,           /// < One Parameter definition
+        MSONParameterSectionType,       /// < One Parameter definition using the MSON syntax
         ValuesSectionType,              /// < Value enumeration
-        ValueSectionType                /// < One Value
+        ValueSectionType,               /// < One Value
+        MSONMixinSectionType,           /// < MSON Mixin
+        MSONNamedTypeSectionType,       /// < MSON Named Type
+        MSONOneOfSectionType,           /// < MSON One Of
+        MSONPropertyMemberSectionType,  /// < MSON Property Member Type
+        MSONSampleDefaultSectionType,   /// < MSON Sample/Default Type Section
+        MSONPropertyMembersSectionType, /// < MSON Property Members Type Section
+        MSONValueMembersSectionType,    /// < MSON Value Members Type Section
+        MSONValueMemberSectionType,     /// < MSON Value Member Type
+        MSONSectionType                 /// < MSON Property Member or Value Member
     };
 
     /** \return Human readable name for given %SectionType */

data/ext/{snowcrash → drafter/ext/snowcrash}/src/SectionParser.h

@@ -10,7 +10,7 @@
 #define SNOWCRASH_SECTIONPARSER_H
 
 #include <stdexcept>
-#include "SectionProcessor.h"
+#include "SignatureSectionProcessor.h"
 
 #define ADAPTER_MISMATCH_ERR std::logic_error("mismatched adapter and node type")
 
@@ -107,6 +107,8 @@ namespace snowcrash {
 
             SectionType lastSectionType = UndefinedSectionType;
 
+            SectionProcessor<T>::preprocessNestedSections(node, collection, pd, out);
+
             // Nested sections
             while(cur != collection.end()) {
 

data/ext/{snowcrash → drafter/ext/snowcrash}/src/SectionParserData.h

@@ -9,9 +9,9 @@
 #ifndef SNOWCRASH_SECTIONPARSERDATA_H
 #define SNOWCRASH_SECTIONPARSERDATA_H
 
+#include "ModelTable.h"
 #include "BlueprintSourcemap.h"
 #include "Section.h"
-#include "SymbolTable.h"
 
 namespace snowcrash {
 
@@ -42,11 +42,20 @@ namespace snowcrash {
         /** Parser Options */
         BlueprintParserOptions options;
 
-        /** Symbol Table */
-        SymbolTable symbolTable;
+        /** Named Types */
+        std::vector<mson::NamedType> msonTypesTable;
 
-        /** Symbol Table Sourcemap */
-        SymbolSourceMapTable symbolSourceMapTable;
+        /** Table of named types and resolved base types */
+        mson::NamedTypeBaseTable namedTypeBaseTable;
+
+        /** Table mapping named type to sub types */
+        mson::NamedTypeInheritanceTable namedTypeInheritanceTable;
+
+        /** Model Table */
+        ModelTable modelTable;
+
+        /** Model Table Sourcemap */
+        ModelSourceMapTable modelSourceMapTable;
 
         /** Source Data */
         const mdp::ByteBuffer& sourceData;
@@ -69,6 +78,7 @@ namespace snowcrash {
                 return UndefinedSectionType;
 
             size_t size = sectionsContext.size();
+
             if (size == 1)
                 return sectionsContext.back();
             else

data/ext/{snowcrash → drafter/ext/snowcrash}/src/SectionProcessor.h

@@ -13,6 +13,20 @@
 #include "SourceAnnotation.h"
 #include "Signature.h"
 
+// Use the following macro whenever a section doesn't have description
+#define NO_SECTION_DESCRIPTION(T)\
+static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,\
+                                               const MarkdownNodes& siblings,\
+                                               SectionParserData& pd,\
+                                               const ParseResultRef<T>& out) {\
+    return node;\
+}\
+\
+static bool isDescriptionNode(const MarkdownNodeIterator& node,\
+                              SectionType sectionType) {\
+    return false;\
+}\
+
 namespace snowcrash {
 
     using mdp::MarkdownNode;
@@ -154,6 +168,16 @@ namespace snowcrash {
             return ++MarkdownNodeIterator(node);
         }
 
+        /**
+         * Pre-process for nested sections, basically a look-ahead before processing nested sections
+         * Only used by BlueprintParser for now
+         */
+        static void preprocessNestedSections(const MarkdownNodeIterator& node,
+                                             const MarkdownNodes& siblings,
+                                             SectionParserData& pd,
+                                             const ParseResultRef<T>& out) {
+        }
+
         /**
          *  \brief Process nested sections Markdown node(s)
          *  \param node     Node to process

data/ext/{snowcrash → drafter/ext/snowcrash}/src/Signature.cc

@@ -15,6 +15,8 @@
 #include "ParametersParser.h"
 #include "ResourceParser.h"
 #include "ResourceGroupParser.h"
+#include "MSONTypeSectionParser.h"
+#include "DataStructureGroupParser.h"
 
 using namespace snowcrash;
 
@@ -23,12 +25,18 @@ SectionType snowcrash::SectionKeywordSignature(const mdp::MarkdownNodeIterator&
     // Note: Every-keyword defined section should be listed here...
     SectionType type = UndefinedSectionType;
 
+    if ((type = SectionProcessor<mson::TypeSection>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
     if ((type = SectionProcessor<Headers>::sectionType(node)) != UndefinedSectionType)
         return type;
 
     if ((type = SectionProcessor<Asset>::sectionType(node)) != UndefinedSectionType)
         return type;
 
+    if ((type = SectionProcessor<Attributes>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
     if ((type = SectionProcessor<Payload>::sectionType(node)) != UndefinedSectionType)
         return type;
 
@@ -38,6 +46,9 @@ SectionType snowcrash::SectionKeywordSignature(const mdp::MarkdownNodeIterator&
     if ((type = SectionProcessor<Parameters>::sectionType(node)) != UndefinedSectionType)
         return type;
 
+    if ((type = SectionProcessor<Relation>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
     /*
      *  NOTE: Order is important. Resource MUST preceed the Action.
      *
@@ -53,6 +64,9 @@ SectionType snowcrash::SectionKeywordSignature(const mdp::MarkdownNodeIterator&
     if ((type = SectionProcessor<ResourceGroup>::sectionType(node)) != UndefinedSectionType)
         return type;
 
+    if ((type = SectionProcessor<DataStructureGroup>::sectionType(node)) != UndefinedSectionType)
+        return type;
+
     return type;
 }
 

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

@@ -0,0 +1,80 @@
+//
+//  Signature.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 5/14/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SIGNATURE_H
+#define SNOWCRASH_SIGNATURE_H
+
+#include "MarkdownNode.h"
+#include "Section.h"
+
+namespace snowcrash {
+
+    /**
+     *  \brief Query whether a node has keyword-defined signature.
+     *  \param node     A Markdown AST node to check.
+     *  \return Type of the node if it has a recognized keyword signature, UndefinedType otherwise
+     */
+    extern SectionType SectionKeywordSignature(const mdp::MarkdownNodeIterator& node);
+
+    /**
+     *  \brief Recognize the type of section given the first line from a code block
+     *  \param subject  The first line that needs to be recognized
+     *  \return SectionType Type of the section if the line contains a keyword
+     */
+    extern SectionType RecognizeCodeBlockFirstLine(const mdp::ByteBuffer& subject);
+}
+
+namespace scpl {
+
+    /**
+     * \brief Signature data after parsing section using signature traits
+     */
+    struct Signature {
+
+        mdp::ByteBuffer identifier;              // Signature Identifier
+        mdp::ByteBuffer value;                   // Signature Value (unparsed values)
+
+        std::vector<mdp::ByteBuffer> values;     // Signature Values
+        std::vector<mdp::ByteBuffer> attributes; // Signature Attributes
+
+        mdp::ByteBuffer content;          // Signature content before newline character
+        mdp::ByteBuffer remainingContent; // Signature content after newline character
+    };
+
+    /**
+     * \brief Traits characteristics of a section signature
+     *
+     * Traits describe identifier defined or value/type defined signatures.
+     */
+    struct SignatureTraits {
+
+        enum Trait {
+            IdentifierTrait = (1 << 0), // Expect an identifier in the signature
+            ValuesTrait     = (1 << 1), // Expect a (list of) value in the signature
+            AttributesTrait = (1 << 2), // Expect a list of attributes in the signature
+            ContentTrait    = (1 << 3)  // Expect inline description in the signature
+        };
+
+        typedef unsigned int Traits;
+
+        const bool identifierTrait;
+        const bool valuesTrait;
+        const bool attributesTrait;
+        const bool contentTrait;
+
+        SignatureTraits(Traits traits_ = 0)
+        :
+        identifierTrait(traits_ & IdentifierTrait),
+        valuesTrait(traits_ & ValuesTrait),
+        attributesTrait(traits_ & AttributesTrait),
+        contentTrait(traits_ & ContentTrait)
+        {}
+    };
+}
+
+#endif

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

@@ -0,0 +1,439 @@
+//
+//  SignatureSectionProcessor.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 10/14/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_SIGNATURESECTIONPROCESSOR_H
+#define SNOWCRASH_SIGNATURESECTIONPROCESSOR_H
+
+#include "SectionProcessor.h"
+
+namespace scpl {
+
+    using mdp::MarkdownNode;
+    using mdp::MarkdownNodes;
+    using mdp::MarkdownNodeIterator;
+
+    const char EscapeCharacter = '`';
+    const char ValuesDelimiter = ':';
+    const char ValueDelimiter = ',';
+    const char AttributesBeginDelimiter = '(';
+    const char AttributesEndDelimiter = ')';
+    const char AttributeDelimiter = ',';
+    const char ContentDelimiter = '-';
+
+    /**
+     * \brief Signature Section Processor Base
+     *
+     * Defines default behaviours for Section Processor interface for Signature sections
+     */
+    template<typename T>
+    struct SignatureSectionProcessorBase : public snowcrash::SectionProcessorBase<T> {
+
+        /**
+         * \brief Signature traits of the section
+         *
+         * \return Signature traits given for section
+         */
+        static SignatureTraits signatureTraits() {
+
+            SignatureTraits signatureTraits;
+            return signatureTraits;
+        };
+
+        /**
+         * \brief Process section signature markdown node (Default)
+         */
+        static MarkdownNodeIterator processSignature(const MarkdownNodeIterator& node,
+                                                     const MarkdownNodes& siblings,
+                                                     snowcrash::SectionParserData& pd,
+                                                     snowcrash::SectionLayout& layout,
+                                                     const snowcrash::ParseResultRef<T>& out) {
+
+            // Get the signature traits of the section
+            SignatureTraits signatureTraits = snowcrash::SectionProcessor<T>::signatureTraits();
+
+            // Parse Signature
+            Signature signature = snowcrash::SectionProcessor<T>::parseSignature(node, pd, signatureTraits, out.report);
+
+            // Do section specific logic using the signature data
+            return snowcrash::SectionProcessor<T>::finalizeSignature(node, pd, signature, out);
+        };
+
+        /**
+         * \brief Parse section signature markdown node
+         *
+         * \param node Markdown node
+         * \param pd Section Parser data
+         * \param traits Signature traits of the section signature
+         * \param report Parse result report of the section
+         * \param subjectOrig The string that needs to be parsed
+         *
+         * \return Signature data
+         */
+        static Signature parseSignature(const MarkdownNodeIterator& node,
+                                        snowcrash::SectionParserData& pd,
+                                        const SignatureTraits& traits,
+                                        snowcrash::Report& report,
+                                        const mdp::ByteBuffer& subjectOrig = "") {
+
+            Signature signature;
+            mdp::ByteBuffer subject = subjectOrig;
+
+            if (subject.empty()) {
+
+                subject = snowcrash::GetFirstLine(node->text, signature.remainingContent);
+                snowcrash::TrimString(subject);
+            }
+
+            if (traits.identifierTrait &&
+                !subject.empty()) {
+
+                parseSignatureIdentifier(traits, report, subject, signature);
+
+                if (signature.identifier.empty()) {
+
+                    // WARN: Empty identifier
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    report.warnings.push_back(snowcrash::Warning("no identifier specified",
+                                                                 snowcrash::EmptyDefinitionWarning,
+                                                                 sourceMap));
+                }
+            }
+
+            // Make sure values exist
+            if (traits.valuesTrait &&
+                !subject.empty() &&
+                subject[0] != AttributesBeginDelimiter) {
+
+                // When subject starts with values, add a ':' for easier processing
+                if (!traits.identifierTrait) {
+                    subject = ValuesDelimiter + subject;
+                }
+
+                if (subject[0] == ValuesDelimiter) {
+
+                    parseSignatureValues(traits, report, subject, signature);
+
+                    if (signature.values.empty()) {
+
+                        // WARN: Empty values
+                        mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                        report.warnings.push_back(snowcrash::Warning("no value(s) specified",
+                                                                     snowcrash::EmptyDefinitionWarning,
+                                                                     sourceMap));
+                    }
+                }
+            }
+
+            if (traits.attributesTrait &&
+                !subject.empty() &&
+                subject[0] != ContentDelimiter) {
+
+                parseSignatureAttributes(report, subject, signature);
+            }
+
+            if (traits.contentTrait &&
+                !subject.empty() &&
+                subject[0] == ContentDelimiter) {
+
+                subject = subject.substr(1);
+                snowcrash::TrimString(subject);
+
+                signature.content = subject;
+            }
+
+            return signature;
+        };
+
+        /**
+         * \brief Use the signature data to do section specific logic
+         *
+         * \param node Markdown node
+         * \param pd Section Parser data
+         * \param signature Signature data
+         * \param out Parse result of the section
+         *
+         * \return Result of process operation
+         */
+        static MarkdownNodeIterator finalizeSignature(const MarkdownNodeIterator& node,
+                                                      snowcrash::SectionParserData& pd,
+                                                      const Signature& signature,
+                                                      const snowcrash::ParseResultRef<T>& out) {
+
+            return ++MarkdownNodeIterator(node);
+        };
+
+        /**
+         * \brief Parse the identifier from the signature
+         *
+         * \param traits Signature traits of the section signature
+         * \param report Parse Report
+         * \param subject String that needs to be parsed
+         *                (which will be stripped of the parsed characters)
+         * \param out Signature data structure
+         */
+        static void parseSignatureIdentifier(const SignatureTraits& traits,
+                                             snowcrash::Report& report,
+                                             mdp::ByteBuffer& subject,
+                                             Signature& out) {
+
+            snowcrash::TrimString(subject);
+
+            // `*` and `_` are markdown characters for emphasis
+            std::string escapeCharacters = "*_`";
+
+            size_t i = 0;
+            mdp::ByteBuffer identifier;
+
+            // Traverse over the string
+            while (i < subject.length()) {
+
+                if (escapeCharacters.find(subject[i]) != std::string::npos) {
+
+                    // If escaped string, retrieve it and strip it from the subject
+                    mdp::ByteBuffer escapedString = snowcrash::RetrieveEscaped(subject, i);
+
+                    if (!escapedString.empty()) {
+                        identifier += escapedString;
+                        i = 0;
+                    } else {
+                        identifier += subject[i];
+                        i++;
+                    }
+                } else if ((traits.valuesTrait && subject[i] == ValuesDelimiter) ||
+                           (traits.attributesTrait && subject[i] == AttributesBeginDelimiter) ||
+                           (traits.contentTrait && subject[i] == ContentDelimiter)) {
+
+                    // If identifier ends, strip it from the subject
+                    subject = subject.substr(i);
+                    i = 0;
+                    break;
+                } else {
+
+                    identifier += subject[i];
+                    i++;
+                }
+            }
+
+            // Assign the identifier
+            snowcrash::TrimString(identifier);
+
+            if (!identifier.empty()) {
+                out.identifier = snowcrash::StripBackticks(identifier);
+            }
+
+            // If the subject ended with the identifier, strip it from the subject
+            if (i == subject.length()) {
+                subject = "";
+            }
+
+            snowcrash::TrimString(subject);
+        };
+
+        /**
+         * \brief Parse the values from the signature
+         *
+         * \param traits Signature traits of the section signature
+         * \param report Parse Report
+         * \param subject String that needs to be parsed
+         *                (which will be stripped of the parsed characters)
+         * \param out Signature data structure
+         */
+        static void parseSignatureValues(const SignatureTraits& traits,
+                                         snowcrash::Report& report,
+                                         mdp::ByteBuffer& subject,
+                                         Signature& out) {
+
+            // Remove leading delimiter
+            subject = subject.substr(1);
+            snowcrash::TrimString(subject);
+
+            size_t i = 0;
+            mdp::ByteBuffer value;
+
+            out.value = subject;
+
+            // Traverse over the string
+            while (i < subject.length()) {
+
+                if (subject[i] == EscapeCharacter) {
+
+                    // If escaped string, retrieve it and strip it from subject
+                    mdp::ByteBuffer escapedString = snowcrash::RetrieveEscaped(subject, i);
+
+                    if (!escapedString.empty()) {
+                        value += escapedString;
+                        i = 0;
+                    } else {
+                        value += subject[i];
+                        i++;
+                    }
+                } else if (subject[i] == ValueDelimiter) {
+
+                    // If found value delimiter, add the value and strip it from subject
+                    subject = subject.substr(i + 1);
+                    snowcrash::TrimString(subject);
+
+                    snowcrash::TrimString(value);
+                    out.values.push_back(snowcrash::StripBackticks(value));
+
+                    value = "";
+                    i = 0;
+                } else if ((traits.attributesTrait && subject[i] == AttributesBeginDelimiter) ||
+                           (traits.contentTrait && subject[i] == ContentDelimiter)) {
+
+                    // If values section ends, strip it from subject
+                    subject = subject.substr(i);
+                    i = 0;
+                    break;
+                } else {
+
+                    value += subject[i];
+                    i++;
+                }
+            }
+
+            // Add the value at the end of values section if present
+            snowcrash::TrimString(value);
+
+            if (!value.empty()) {
+                out.values.push_back(snowcrash::StripBackticks(value));
+            }
+
+            // If the subject ended with the values, strip the last value from the subject
+            if (i == subject.length()) {
+                subject = "";
+            }
+
+            snowcrash::TrimString(subject);
+
+            // Fill signature value with the string which was stripped from subject
+            out.value = out.value.substr(0, out.value.length() - subject.length());
+
+            snowcrash::TrimString(out.value);
+            out.value = snowcrash::StripBackticks(out.value);
+        };
+
+        /**
+         * \brief Parse the attributes from the signature
+         *
+         * \param report Parse Report
+         * \param subject String that needs to be parsed
+         *                (which will be stripped of the parsed characters)
+         * \param out Signature data structure
+         */
+        static void parseSignatureAttributes(snowcrash::Report& report,
+                                             mdp::ByteBuffer& subject,
+                                             Signature& out) {
+
+            if (subject[0] != AttributesBeginDelimiter) {
+                return;
+            }
+
+            bool attributesNotFinished = true;
+
+            // While there are attributes still left
+            while (attributesNotFinished) {
+
+                // Retrieve attribute
+                mdp::ByteBuffer attribute = matchBrackets(subject, 0, AttributesEndDelimiter, true);
+                size_t length = attribute.size();
+
+                // If the last char is not an attribute delimiter, attributes are finished
+                if (attribute[length - 1] != AttributeDelimiter) {
+                    attributesNotFinished = false;
+                } else {
+                    attribute = attribute.substr(0, length - 1);
+
+                    // For easier processing
+                    subject = AttributesBeginDelimiter + subject;
+                }
+
+                snowcrash::TrimString(attribute);
+
+                if (!attribute.empty()) {
+                    out.attributes.push_back(attribute);
+                }
+            };
+
+            snowcrash::TrimString(subject);
+        };
+
+        /**
+         * \brief Find the matching bracket while ignoring any nested brackets and return the string
+         *        enclosed by them, while also stripping the string that needs to be parsed
+         *
+         * \param subject The string that needs to be parsed
+         * \param begin Character index representing the beginning of the bracket that needs to be matched
+         * \param endBracket The type of bracket that needs to be matched
+         * \param splitByAttribute If this is true, we need to return when we find a top-level attribute delimiter
+         *
+         * \return String inside the given brackets. If not splitting by comma, append the brackets too
+         */
+        static mdp::ByteBuffer matchBrackets(mdp::ByteBuffer& subject,
+                                             size_t begin,
+                                             const char endBracket,
+                                             const bool splitByAttribute = false) {
+
+            size_t i = begin + 1;
+            mdp::ByteBuffer returnString;
+
+            // Append the beginning bracket
+            if (!splitByAttribute) {
+                returnString += subject[begin];
+            }
+
+            while (i < subject.length()) {
+
+                if (subject[i] == EscapeCharacter) {
+
+                    // If escaped string, retrieve it and strip it from subject
+                    mdp::ByteBuffer escapedString = snowcrash::RetrieveEscaped(subject, i);
+
+                    if (!escapedString.empty()) {
+                        returnString += escapedString;
+                        i = 0;
+                    } else {
+                        returnString += subject[i];
+                        i++;
+                    }
+                } else if (subject[i] == '[') {
+
+                    returnString += matchBrackets(subject, i, ']');
+                    i = 0;
+                } else if (subject[i] == '(') {
+
+                    returnString += matchBrackets(subject, i, ')');
+                    i = 0;
+                } else if (subject[i] == endBracket) {
+
+                    // Append the ending bracket
+                    if (!splitByAttribute) {
+                        returnString += subject[i];
+                    }
+
+                    subject = subject.substr(i + 1);
+                    break;
+                } else if (splitByAttribute && subject[i] == AttributeDelimiter) {
+
+                    // Return when encountering comma
+                    returnString += subject[i];
+                    subject = subject.substr(i + 1);
+                    break;
+                } else {
+
+                    returnString += subject[i];
+                    i++;
+                }
+            }
+
+            return returnString;
+        }
+    };
+}
+
+#endif