redsnow 0.3.7 → 0.4.0

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

@@ -0,0 +1,81 @@
+//
+//  BlueprintSourcemap.cc
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 26/01/15.
+//  Copyright (c) 2015 Apiary Inc. All rights reserved.
+//
+
+#include "BlueprintSourcemap.h"
+
+using namespace snowcrash;
+
+SourceMap<Elements>& SourceMap<Element>::Content::elements()
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+const SourceMap<Elements>& SourceMap<Element>::Content::elements() const
+{
+    if (!m_elements.get())
+        throw ELEMENTS_NOT_SET_ERR;
+
+    return *m_elements;
+}
+
+SourceMap<Element>::Content::Content()
+{
+    m_elements.reset(::new SourceMap<Elements>);
+}
+
+SourceMap<Element>::Content::Content(const SourceMap<Element>::Content& rhs)
+{
+    this->copy = rhs.copy;
+    this->resource = rhs.resource;
+    this->dataStructure = rhs.dataStructure;
+    m_elements.reset(::new SourceMap<Elements>(*rhs.m_elements.get()));
+}
+
+SourceMap<Element>::Content& SourceMap<Element>::Content::operator=(const SourceMap<Element>::Content& rhs)
+{
+    this->copy = rhs.copy;
+    this->resource = rhs.resource;
+    this->dataStructure = rhs.dataStructure;
+    m_elements.reset(::new SourceMap<Elements>(*rhs.m_elements.get()));
+
+    return *this;
+}
+
+SourceMap<Element>::Content::~Content()
+{
+}
+
+SourceMap<Element>::SourceMap(const Element::Class& element_)
+: element(element_)
+{
+}
+
+SourceMap<Element>::SourceMap(const SourceMap<Element>& rhs)
+{
+    this->element = rhs.element;
+    this->attributes = rhs.attributes;
+    this->content = rhs.content;
+    this->category = rhs.category;
+}
+
+SourceMap<Element>& SourceMap<Element>::operator=(const SourceMap<Element>& rhs)
+{
+    this->element = rhs.element;
+    this->attributes = rhs.attributes;
+    this->content = rhs.content;
+    this->category = rhs.category;
+
+    return *this;
+}
+
+SourceMap<Element>::~SourceMap()
+{
+}

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

@@ -10,8 +10,7 @@
 #define SNOWCRASH_BLUEPRINT_SOURCEMAP_H
 
 #include "Blueprint.h"
-#include "MarkdownParser.h"
-
+#include "MSONSourcemap.h"
 /**
  *  API Blueprint Sourcemap Abstract Syntax Tree
  *  ---------------------------------------------
@@ -19,21 +18,8 @@
  *  Data types in this documents define the API Blueprint Sourcemap AST.
  */
 
-#define SOURCE_MAP_COLLECTION(T, TC) template<>\
-struct SourceMap<TC> {\
-    Collection<SourceMap<T> >::type collection;\
-};\
-
 namespace snowcrash {
 
-    struct SourceMapBase {
-        mdp::BytesRangeSet sourceMap;
-    };
-
-    template<typename T>
-    struct SourceMap : public SourceMapBase {
-    };
-
     /** Source Map of Metadata Collection */
     SOURCE_MAP_COLLECTION(Metadata, MetadataCollection)
 
@@ -43,7 +29,9 @@ namespace snowcrash {
     /** Source Map of Collection of Parameter values */
     SOURCE_MAP_COLLECTION(Value, Values)
 
-    /** Source Map Structure for Parameter */
+    /**
+     * Source Map Structure for Parameter
+     */
     template<>
     struct SourceMap<Parameter> : public SourceMapBase {
 
@@ -69,9 +57,26 @@ namespace snowcrash {
         SourceMap<Values> values;
     };
 
+    /**
+     * Source Map Structure for MSON Parameter
+     */
+    template<>
+    struct SourceMap<MSONParameter> : public SourceMap<Parameter> {
+    };
+
     /** Source Map of Collection of Parameters */
     SOURCE_MAP_COLLECTION(Parameter, Parameters)
 
+    /**
+     * Source Map Structure for DataStructure
+     */
+    template<>
+    struct SourceMap<DataStructure> : public SourceMap<mson::NamedType> {
+    };
+
+    /** Source Map Structure for Attributes */
+    // 'Attributes' is the same as 'DataStructure'
+
     /**
      * Source Map Structure for Payload
      */
@@ -84,19 +89,22 @@ namespace snowcrash {
         /** Source Map of Payload Description */
         SourceMap<Description> description;
 
-        /** Payload-specific Parameters */
+        /** Source Map of Payload-specific Parameters */
         SourceMap<Parameters> parameters;
 
-        /** Payload-specific Headers */
+        /** Source Map of Payload-specific Headers */
         SourceMap<Headers> headers;
 
-        /** Source Map of Body */
+        /** Source Map of Payload-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        SourceMap<Attributes> attributes;
+
+        /** Source Map of Body (THIS SHOULD NOT BE HERE - should be under content) */
         SourceMap<Asset> body;
 
-        /** Source Map of Schema */
+        /** Source Map of Schema (THIS SHOULD NOT BE HERE - should be under content) */
         SourceMap<Asset> schema;
 
-        /** Source Map of Symbol */
+        /** Source Map of Model Reference */
         SourceMap<Reference> reference;
     };
 
@@ -146,6 +154,15 @@ namespace snowcrash {
         /** Action-specific Parameters */
         SourceMap<Parameters> parameters;
 
+        /** Action-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        SourceMap<Attributes> attributes;
+
+        /** Source Map of URI Template (THIS SHOULD NOT BE HERE - should be under element attributes) */
+        SourceMap<URITemplate> uriTemplate;
+
+        /** Source Map of Link Relation (THIS SHOULD NOT BE HERE - should be under element attributes) */
+        SourceMap<Relation> relation;
+
         /**
          *  \brief Action-specific HTTP headers
          *
@@ -171,7 +188,7 @@ namespace snowcrash {
      *  Source Map Structure for API Resource
      */
     template<>
-    struct SourceMap<Resource> : public SourceMapBase {
+    struct SourceMap<Resource> {
 
         /** Source Map of URI template */
         SourceMap<URITemplate> uriTemplate;
@@ -185,6 +202,9 @@ namespace snowcrash {
         /** Model representing this Resource */
         SourceMap<ResourceModel> model;
 
+        /** Source Map of Resource-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        SourceMap<Attributes> attributes;
+
         /** Parameters */
         SourceMap<Parameters> parameters;
 
@@ -209,24 +229,96 @@ namespace snowcrash {
     /** Source Map of Collection of Resources */
     SOURCE_MAP_COLLECTION(Resource, Resources)
 
+    /** Forward Declaration for Source Map of Element */
+    template<>
+    struct SourceMap<Element>;
+
+    /** Source Map of Collection of Elements */
+    SOURCE_MAP_COLLECTION(Element, Elements)
+
     /**
-     *  Source Map Structure for Group of API Resources
+     * Source Map Structure for Element
      */
     template<>
-    struct SourceMap<ResourceGroup> : public SourceMapBase {
+    struct SourceMap<Element> : public SourceMapBase {
 
-        /** Source Map of a Group Name */
-        SourceMap<Name> name;
+        /** Source Map Structure for Attributes of the Element */
+        struct Attributes {
 
-        /** Source Map of Group description */
-        SourceMap<Description> description;
+            /** Source Map of a Element Name */
+            SourceMap<Name> name;
+        };
+
+        /** Source Map Structure for Content of the Element */
+        struct Content {
+
+            /** EITHER Source Map of Copy */
+            SourceMap<std::string> copy;
 
-        /** Resources */
-        SourceMap<Resources> resources;
+            /** OR Source Map of Resource */
+            SourceMap<Resource> resource;
+
+            /** OR Source Map of Data Structure */
+            SourceMap<DataStructure> dataStructure;
+
+            /** OR Source Map of Collection of elements */
+            SourceMap<Elements>& elements();
+            const SourceMap<Elements>& elements() const;
+
+            /** Constructor */
+            Content();
+
+            /** Copy constructor */
+            Content(const SourceMap<Element>::Content& rhs);
+
+            /** Assignment operator */
+            SourceMap<Element>::Content& operator=(const SourceMap<Element>::Content& rhs);
+
+            /** Destructor */
+            ~Content();
+
+        private:
+            std::auto_ptr<SourceMap<Elements> > m_elements;
+        };
+
+        /** Class of the Element (to be used internally only) */
+        Element::Class element;
+
+        /** Source Map of Attributes of the Element */
+        Attributes attributes;
+
+        /** Source Map of Content of the Element */
+        Content content;
+
+        /** Type of the Category element (to be used internally only) */
+        Element::Category category;
+
+        /** Constructor */
+        SourceMap(const Element::Class& element_ = Element::UndefinedElement);
+
+        /** Copy constructor */
+        SourceMap(const SourceMap<Element>& rhs);
+
+        /** Assignment operator */
+        SourceMap<Element>& operator=(const SourceMap<Element>& rhs);
+
+        /** Destructor */
+        ~SourceMap();
+    };
+
+    /**
+     *  Source Map Structure for Group of API Resources (Category Element)
+     */
+    template<>
+    struct SourceMap<ResourceGroup> : public SourceMap<Element> {
     };
 
-    /** Source Map of Collection of Resource groups */
-    SOURCE_MAP_COLLECTION(ResourceGroup, ResourceGroups)
+    /**
+     * Source Map Structure for Group of Data Structures (Category Element)
+     */
+    template<>
+    struct SourceMap<DataStructureGroup> : public SourceMap<Element> {
+    };
 
     /**
      *  \brief API Blueprint Sourcemap AST
@@ -235,20 +327,19 @@ namespace snowcrash {
      *  Start reading a parsed API here.
      */
     template<>
-    struct SourceMap<Blueprint> : public SourceMapBase {
-
-        /** Source Map of API Blueprint metadata */
-        SourceMap<MetadataCollection> metadata;
+    struct SourceMap<Blueprint> : public SourceMap<Element> {
 
         /** Source Map of the API Name */
         SourceMap<Name> name;
 
+        /** Source Map of API Blueprint metadata */
+        SourceMap<MetadataCollection> metadata;
+
         /** Source Map of an API Overview description */
         SourceMap<Description> description;
-
-        /** The set of API Resource Groups */
-        SourceMap<ResourceGroups> resourceGroups;
     };
 }
 
+#undef SOURCE_MAP_COLLECTION
+
 #endif

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

@@ -94,10 +94,16 @@ namespace snowcrash {
     };
 
     /**  Action matching predicate. */
-    template <class T>
-    struct MatchAction : std::binary_function<T, T, bool> {
-        bool operator()(const T& first, const T& second) const {
-            return first.method == second.method;
+    struct MatchAction : std::binary_function<Action, Action, bool> {
+        bool operator()(const first_argument_type& first, const second_argument_type& second) const {
+            return first.uriTemplate == second.uriTemplate && first.method == second.method;
+        }
+    };
+
+    /** Relation matching predicate. */
+    struct MatchRelation : std::binary_function<Action, Relation, bool> {
+        bool operator()(const first_argument_type& first, const second_argument_type& second) const {
+            return !first.relation.str.empty() && !second.str.empty() && first.relation.str == second.str;
         }
     };
 }

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

@@ -254,7 +254,7 @@ namespace snowcrash {
 
             TrimString(source);
 
-            if(GetSymbolReference(source, symbol)) {
+            if(GetModelReference(source, symbol)) {
 
                 std::stringstream ss;
                 ss << "found a possible '" << symbol << "' model reference, ";

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

@@ -0,0 +1,154 @@
+//
+//  DataStructureGroupParser.h
+//  snowcrash
+//
+//  Created by Pavan Kumar Sunkara on 02/12/14.
+//  Copyright (c) 2014 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_DATASTRUCTUREGROUPPARSER_H
+#define SNOWCRASH_DATASTRUCTUREGROUPPARSER_H
+
+#include "MSONNamedTypeParser.h"
+
+using namespace scpl;
+
+namespace snowcrash {
+
+    /** Data structure group matching regex */
+    const char* const DataStructureGroupRegex = "^[[:blank:]]*[Dd]ata[[:blank:]]+[Ss]tructures?[[:blank:]]*$";
+
+    /**
+     * Data structure group section processor
+     */
+    template<>
+    struct SectionProcessor<DataStructureGroup> : public SectionProcessorBase<DataStructureGroup> {
+
+        NO_SECTION_DESCRIPTION(DataStructureGroup)
+
+        static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
+                                                         const MarkdownNodes& siblings,
+                                                         SectionParserData& pd,
+                                                         const ParseResultRef<DataStructureGroup>& out) {
+
+            MarkdownNodeIterator cur = node;
+
+            if (pd.sectionContext() == MSONNamedTypeSectionType) {
+
+                IntermediateParseResult<mson::NamedType> namedType(out.report);
+                cur = MSONNamedTypeParser::parse(node, siblings, pd, namedType);
+
+                if (isNamedTypeDuplicate(pd.blueprint, namedType.node.name.symbol.literal)) {
+
+                    // WARN: duplicate named type
+                    std::stringstream ss;
+                    ss << "named type with name '" << namedType.node.name.symbol.literal << "' already exists";
+
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                    out.report.warnings.push_back(Warning(ss.str(),
+                                                          DuplicateWarning,
+                                                          sourceMap));
+                }
+                else {
+
+                    Element element(Element::DataStructureElement);
+                    element.content.dataStructure = namedType.node;
+
+                    out.node.content.elements().push_back(element);
+
+                    if (pd.exportSourceMap()) {
+
+                        SourceMap<Element> elementSM(Element::DataStructureElement);
+
+                        elementSM.content.dataStructure.name = namedType.sourceMap.name;
+                        elementSM.content.dataStructure.typeDefinition = namedType.sourceMap.typeDefinition;
+                        elementSM.content.dataStructure.sections = namedType.sourceMap.sections;
+
+                        out.sourceMap.content.elements().collection.push_back(elementSM);
+                    }
+                }
+            }
+
+            return cur;
+        }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<DataStructureGroup>& out) {
+
+            out.node.element = Element::CategoryElement;
+            out.node.category = Element::DataStructureGroupCategory;
+
+            if (pd.exportSourceMap()) {
+
+                out.sourceMap.element = out.node.element;
+                out.sourceMap.category = out.node.category;
+            }
+        }
+
+        static SectionType sectionType(const MarkdownNodeIterator& node) {
+
+            if (node->type == mdp::HeaderMarkdownNodeType &&
+                !node->text.empty()) {
+
+                mdp::ByteBuffer remaining, subject = node->text;
+
+                subject = GetFirstLine(subject, remaining);
+                TrimString(subject);
+
+                if (RegexMatch(subject, DataStructureGroupRegex)) {
+                    return DataStructureGroupSectionType;
+                }
+            }
+
+            return UndefinedSectionType;
+        }
+
+        static SectionType nestedSectionType(const MarkdownNodeIterator& node) {
+
+            return SectionProcessor<mson::NamedType>::sectionType(node);
+        }
+
+        /**
+         * \brief Check if a named type already exists with the given name
+         *
+         * \param blueprint The blueprint which is formed until now
+         * \param name The named type name to be checked
+         */
+        static bool isNamedTypeDuplicate(const Blueprint& blueprint,
+                                         mdp::ByteBuffer& name) {
+
+            for (Elements::const_iterator it = blueprint.content.elements().begin();
+                 it != blueprint.content.elements().end();
+                 ++it) {
+
+                if (it->element == Element::CategoryElement) {
+
+                    for (Elements::const_iterator subIt = it->content.elements().begin();
+                         subIt != it->content.elements().end();
+                         ++subIt) {
+
+                        if (subIt->element == Element::ResourceElement &&
+                            subIt->content.resource.attributes.name.symbol.literal == name) {
+
+                            return true;
+                        }
+
+                        if (subIt->element == Element::DataStructureElement &&
+                            subIt->content.dataStructure.name.symbol.literal == name) {
+
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+    };
+
+    /** Data Structures Parser */
+    typedef SectionParser<DataStructureGroup, HeaderSectionAdapter> DataStructureGroupParser;
+}
+
+#endif