redsnow 0.3.7 → 0.4.0

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

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

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

@@ -14,6 +14,7 @@
 #include <utility>
 #include "Platform.h"
 #include "MarkdownNode.h"
+#include "MSON.h"
 
 /**
  *  API Blueprint Abstract Syntax Tree
@@ -53,18 +54,6 @@ namespace snowcrash {
     /** A generic key - value pair */
     typedef std::pair<std::string, std::string> KeyValuePair;
 
-    /**
-     * Default Container for collections.
-     *
-     *  FIXME: Use C++11 template aliases when migrating to C++11.
-     */
-    template<typename T>
-    struct Collection {
-        typedef std::vector<T> type;
-        typedef typename std::vector<T>::iterator iterator;
-        typedef typename std::vector<T>::const_iterator const_iterator;
-    };
-
     /** An asset data */
     typedef std::string Asset;
 
@@ -82,6 +71,19 @@ namespace snowcrash {
      */
     typedef KeyValuePair Header;
 
+    /**
+     * Default Container for collections.
+     *
+     *  FIXME: Use C++11 template aliases when migrating to C++11.
+     */
+
+    template<typename T>
+    struct Collection {
+        typedef std::vector<T> type;
+        typedef typename std::vector<T>::iterator iterator;
+        typedef typename std::vector<T>::const_iterator const_iterator;
+    };
+
     /** Metadata Collection */
     typedef Collection<Metadata>::type MetadataCollection;
 
@@ -91,6 +93,13 @@ namespace snowcrash {
     /** Collection of Parameter Values */
     typedef Collection<Value>::type Values;
 
+    /** Role of an element */
+    enum AssetRole {
+        UndefinedAssetRole = 0,   // Unknown
+        BodyExampleAssetRole,     // Body example for asset
+        BodySchemaAssetRole       // Body schema for asset
+    };
+
     /** Parameter Use flag */
     enum ParameterUse {
         UndefinedParameterUse,
@@ -123,7 +132,11 @@ namespace snowcrash {
         Values values;
     };
 
-    /** Source Map of Collection of Parameters */
+    /** Parameter with MSON-like syntax */
+    struct MSONParameter : public Parameter {
+    };
+
+    /** Collection of Parameters */
     typedef Collection<Parameter>::type Parameters;
 
     /** Identifier(name) of Reference */
@@ -141,7 +154,7 @@ namespace snowcrash {
 
         /** Reference Type */
         enum ReferenceType {
-            SymbolReference     // Reference as symbol
+            ModelReference  // Resource Model as a reference
         };
 
         /** Identifier */
@@ -152,6 +165,10 @@ namespace snowcrash {
 
         struct ReferenceMetadata {
 
+            /** Constructor */
+            ReferenceMetadata(State state_ = StateUnresolved)
+            : state(state_) {}
+
             /** Markdown AST reference source node (for source map) */
             mdp::MarkdownNodeIterator node;
 
@@ -162,7 +179,21 @@ namespace snowcrash {
         /** Metadata for the reference */
         ReferenceMetadata meta;
     };
-    
+
+    /**
+     * Data Structure
+     */
+    struct DataStructure : public mson::NamedType {
+
+        /** Assignment operator for Named Type */
+        DataStructure& operator=(const mson::NamedType& rhs);
+    };
+
+    /**
+     *  Attributes
+     */
+    typedef DataStructure Attributes;
+
     /**
      *  Payload
      */
@@ -180,10 +211,13 @@ namespace snowcrash {
         /** Payload-specific Headers */
         Headers headers;
 
-        /** Body */
+        /** Payload-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        Attributes attributes;
+
+        /** Body (THIS SHOULD NOT BE HERE - should be under content) */
         Asset body;
 
-        /** Schema */
+        /** Schema (THIS SHOULD NOT BE HERE - should be under content) */
         Asset schema;
 
         /** Reference */
@@ -231,6 +265,15 @@ namespace snowcrash {
     /** Collection of Transaction examples */
     typedef Collection<TransactionExample>::type TransactionExamples;
 
+    /**
+     *  Link relation
+     */
+    struct Relation {
+
+        /** String */
+        std::string str;
+    };
+
     /**
      *  Action
      */
@@ -248,6 +291,15 @@ namespace snowcrash {
         /** Action-specific Parameters */
         Parameters parameters;
 
+        /** Action-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        Attributes attributes;
+
+        /** URI Template (THIS SHOULD NOT BE HERE - should be under element attributes) */
+        URITemplate uriTemplate;
+
+        /** Link Relation (THIS SHOULD NOT BE HERE - should be under element attributes) */
+        Relation relation;
+
         /**
          *  \brief Action-specific HTTP headers
          *
@@ -286,6 +338,9 @@ namespace snowcrash {
         /** Model representing this Resource */
         ResourceModel model;
 
+        /** Resource-specific Attributes (THIS SHOULD NOT BE HERE - should be under content) */
+        Attributes attributes;
+
         /** Parameters */
         Parameters parameters;
 
@@ -310,23 +365,107 @@ namespace snowcrash {
     /** Collection of Resources */
     typedef Collection<Resource>::type Resources;
 
-    /**
-     *  Group of API Resources
-     */
-    struct ResourceGroup {
+    /** Forward declaration of Element */
+    struct Element;
 
-        /** A Group Name */
-        Name name;
+    /** Collection of elements */
+    typedef std::vector<Element> Elements;
 
-        /** Group description */
-        Description description;
+    /** Element */
+    struct Element {
+
+        /** Class of an element */
+        enum Class {
+            UndefinedElement = 0, // Unknown
+            CategoryElement,      // Group of other elements
+            CopyElement,          // Human readable text
+            AssetElement,         // Asset of API description
+            ResourceElement,      // Resource
+            DataStructureElement  // Data Structure
+        };
+
+        /** Attributes of an element */
+        struct Attributes {
+
+            /** Human readable name of the element */
+            Name name;
+        };
+
+        /** Content of an element */
+        struct Content {
+
+            /** EITHER Copy */
+            std::string copy;
+
+            /** OR Resource */
+            Resource resource;
+
+            /** OR Data Structure */
+            DataStructure dataStructure;
+
+            /** OR Collection of elements */
+            Elements& elements();
+            const Elements& elements() const;
+
+            /** Constructor */
+            Content();
+
+            /** Copy constructor */
+            Content(const Element::Content& rhs);
 
-        /** Resources */
-        Resources resources;
+            /** Assignment operator */
+            Content& operator=(const Element::Content& rhs);
+
+            /** Destructor */
+            ~Content();
+
+        private:
+            std::auto_ptr<Elements> m_elements;
+        };
+
+        /** Type of Category element (parser internal flag) */
+        enum Category {
+            UndefinedCategory = 0,     // Unknown
+            ResourceGroupCategory,     // Resource Group
+            DataStructureGroupCategory // Data Structure Group
+        };
+
+        /** Type of the element */
+        Element::Class element;
+
+        /** Attributes of the element */
+        Element::Attributes attributes;
+
+        /** Content of the element */
+        Element::Content content;
+
+        /** Type of Category element (to be used internally only) */
+        Element::Category category;
+
+        /** Constructor */
+        Element(const Element::Class& element_ = Element::UndefinedElement);
+
+        /** Copy constructor */
+        Element(const Element& rhs);
+
+        /** Assignment operator */
+        Element& operator=(const Element& rhs);
+
+        /** Destructor */
+        ~Element();
+    };
+
+    /**
+     *  Group of API Resources (Category Element)
+     */
+    struct ResourceGroup : public Element {
     };
 
-    /** Collection of Resource groups */
-    typedef Collection<ResourceGroup>::type ResourceGroups;
+    /**
+     * Group of Data Structures (Category Element)
+     */
+    struct DataStructureGroup : public Element {
+    };
 
     /**
      *  \brief API Blueprint AST
@@ -334,7 +473,7 @@ namespace snowcrash {
      *  This is top-level (or root if you prefer) of API Blueprint abstract syntax tree.
      *  Start reading a parsed API here.
      */
-    struct Blueprint {
+    struct Blueprint : public Element {
 
         /** Metadata */
         MetadataCollection metadata;
@@ -344,9 +483,6 @@ namespace snowcrash {
 
         /** An API Overview description */
         Description description;
-
-        /** The set of API Resource Groups */
-        ResourceGroups resourceGroups;
     };
 }
 

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

@@ -11,6 +11,7 @@
 
 #include "ResourceParser.h"
 #include "ResourceGroupParser.h"
+#include "DataStructureGroupParser.h"
 #include "SectionParser.h"
 #include "RegexMatch.h"
 #include "CodeBlockUtility.h"
@@ -68,7 +69,7 @@ namespace snowcrash {
 
                 SectionType nestedType = nestedSectionType(cur);
 
-                // Resources Groups only, parse as exclusive nested sections
+                // Nested Sections only, parse as exclusive nested sections
                 if (nestedType != UndefinedSectionType) {
                     layout = ExclusiveNestedSectionLayout;
                     return cur;
@@ -94,24 +95,23 @@ namespace snowcrash {
                                                          SectionParserData& pd,
                                                          const ParseResultRef<Blueprint>& out) {
 
+            MarkdownNodeIterator cur = node;
+
             if (pd.sectionContext() == ResourceGroupSectionType ||
                 pd.sectionContext() == ResourceSectionType) {
 
                 IntermediateParseResult<ResourceGroup> resourceGroup(out.report);
+                cur = ResourceGroupParser::parse(node, siblings, pd, resourceGroup);
 
-                MarkdownNodeIterator cur = ResourceGroupParser::parse(node, siblings, pd, resourceGroup);
-
-                ResourceGroupIterator duplicate = findResourceGroup(out.node.resourceGroups, resourceGroup.node);
-
-                if (duplicate != out.node.resourceGroups.end()) {
+                if (isResourceGroupDuplicate(out.node, resourceGroup.node.attributes.name)) {
 
                     // WARN: duplicate resource group
                     std::stringstream ss;
 
-                    if (resourceGroup.node.name.empty()) {
+                    if (resourceGroup.node.attributes.name.empty()) {
                         ss << "anonymous group";
                     } else {
-                        ss << "group '" << resourceGroup.node.name << "'";
+                        ss << "group '" << resourceGroup.node.attributes.name << "'";
                     }
 
                     ss << " is already defined";
@@ -122,16 +122,103 @@ namespace snowcrash {
                                                           sourceMap));
                 }
 
-                out.node.resourceGroups.push_back(resourceGroup.node);
+                out.node.content.elements().push_back(resourceGroup.node);
 
                 if (pd.exportSourceMap()) {
-                    out.sourceMap.resourceGroups.collection.push_back(resourceGroup.sourceMap);
+                    out.sourceMap.content.elements().collection.push_back(resourceGroup.sourceMap);
                 }
+            }
+            else if (pd.sectionContext() == DataStructureGroupSectionType) {
 
-                return cur;
+                IntermediateParseResult<DataStructureGroup> dataStructureGroup(out.report);
+                cur = DataStructureGroupParser::parse(node, siblings, pd, dataStructureGroup);
+
+                out.node.content.elements().push_back(dataStructureGroup.node);
+
+                if (pd.exportSourceMap()) {
+                    out.sourceMap.content.elements().collection.push_back(dataStructureGroup.sourceMap);
+                }
+            }
+
+            return cur;
+        }
+
+        /**
+         * Look ahead through all the nested sections and gather list of all
+         * named types along with their base types and the types they are sub-typed from
+         */
+        static void preprocessNestedSections(const MarkdownNodeIterator& node,
+                                             const MarkdownNodes& siblings,
+                                             SectionParserData& pd,
+                                             const ParseResultRef<Blueprint>& out) {
+
+            MarkdownNodeIterator cur = node, contextCur;
+            SectionType sectionType = UndefinedSectionType;
+            SectionType contextSectionType = UndefinedSectionType;
+
+            // Iterate over nested sections
+            while (cur != siblings.end()) {
+
+                sectionType = SectionKeywordSignature(cur);
+
+                // Complete Action is recognized as resource section
+                if (sectionType == ResourceSectionType) {
+
+                    ActionType actionType = SectionProcessor<Action>::actionType(cur);
+
+                    if (actionType == CompleteActionType) {
+                        sectionType = ActionSectionType;
+                    }
+                }
+
+                if (cur->type == mdp::HeaderMarkdownNodeType) {
+
+                    // If the current node is a Resource or DataStructures section, assign it as context
+                    // Otherwise, make sure the current context is not DataStructures section and remove the context
+                    if (sectionType == ResourceSectionType ||
+                        sectionType == DataStructureGroupSectionType) {
+
+                        contextSectionType = sectionType;
+                        contextCur = cur;
+                    }
+                    else if (contextSectionType != DataStructureGroupSectionType) {
+
+                        contextSectionType = UndefinedSectionType;
+                    }
+
+                    // If context is DataStructures section, NamedTypes should be filled
+                    if (contextSectionType == DataStructureGroupSectionType) {
+
+                        if (sectionType != MSONSampleDefaultSectionType &&
+                            sectionType != MSONPropertyMembersSectionType &&
+                            sectionType != MSONValueMembersSectionType &&
+                            sectionType != UndefinedSectionType &&
+                            sectionType != DataStructureGroupSectionType) {
+
+                            contextSectionType = UndefinedSectionType;
+                        }
+                        else if (sectionType == UndefinedSectionType) {
+                            fillNamedTypeTables(cur, pd, cur->text, out.report);
+                        }
+                    }
+                }
+                else if (cur->type == mdp::ListItemMarkdownNodeType &&
+                         contextSectionType == ResourceSectionType &&
+                         sectionType == AttributesSectionType) {
+
+                    Resource resource;
+                    SectionProcessor<Resource>::matchNamedResourceHeader(contextCur, resource);
+
+                    if (!resource.name.empty()) {
+                        fillNamedTypeTables(cur, pd, cur->children().front().text, out.report, resource.name);
+                    }
+                }
+
+                cur++;
             }
 
-            return node;
+            // Resolve all named type base table entries
+            resolveNamedTypeTables(pd, out.report);
         }
 
         static SectionType sectionType(const MarkdownNodeIterator& node) {
@@ -157,6 +244,13 @@ namespace snowcrash {
                 return nestedType;
             }
 
+            // Check if DataStructures section
+            nestedType = SectionProcessor<DataStructureGroup>::sectionType(node);
+
+            if (nestedType != UndefinedSectionType) {
+                return nestedType;
+            }
+
             return UndefinedSectionType;
         }
 
@@ -165,6 +259,7 @@ namespace snowcrash {
 
             // Resource Group & descendants
             nested.push_back(ResourceGroupSectionType);
+            nested.push_back(DataStructureGroupSectionType);
             SectionTypes types = SectionProcessor<ResourceGroup>::nestedSectionTypes();
             nested.insert(nested.end(), types.begin(), types.end());
 
@@ -174,8 +269,13 @@ namespace snowcrash {
         static void finalize(const MarkdownNodeIterator& node,
                              SectionParserData& pd,
                              const ParseResultRef<Blueprint>& out) {
-     
+
             checkLazyReferencing(pd, out);
+            out.node.element = Element::CategoryElement;
+
+            if (pd.exportSourceMap()) {
+                out.sourceMap.element = out.node.element;
+            }
 
             if (!out.node.name.empty())
                 return;
@@ -204,6 +304,144 @@ namespace snowcrash {
             return true;
         }
 
+        /**
+         * \brief Fill named type table entries from the signature information.
+         *        Both base table and inheritance table.
+         *
+         * \param node Markdown node to process
+         * \param pd Section parser data
+         * \param subject Signature of the named type
+         * \param report Parse report
+         * \param name Name of the named type (only given in case of named resource)
+         */
+        static void fillNamedTypeTables(const MarkdownNodeIterator& node,
+                                        SectionParserData& pd,
+                                        const mdp::ByteBuffer& subject,
+                                        Report& report,
+                                        const mdp::ByteBuffer& name = "") {
+
+            mdp::ByteBuffer buffer = subject;
+            mson::Literal identifier;
+            mson::TypeDefinition typeDefinition;
+            Report tmpReport;
+
+            SignatureTraits traits(SignatureTraits::IdentifierTrait |
+                                   SignatureTraits::AttributesTrait);
+
+            Signature signature = SignatureSectionProcessorBase<Blueprint>::parseSignature(node, pd, traits, tmpReport, buffer);
+            mson::parseTypeDefinition(node, pd, signature.attributes, tmpReport, typeDefinition);
+
+            // Name of the named types cannot be variable
+            if (!name.empty() && mson::checkVariable(signature.identifier)) {
+                return;
+            }
+
+            if (!name.empty()) {
+                identifier = name;
+            }
+            else {
+                identifier = signature.identifier;
+            }
+
+            // If named type already exists, do nothing
+            mson::NamedTypeBaseTable::iterator it = pd.namedTypeBaseTable.find(identifier);
+
+            if (it != pd.namedTypeBaseTable.end()) {
+                return;
+            }
+
+            // Otherwise, add the respective entries to the tables
+            if (typeDefinition.typeSpecification.name.base != mson::UndefinedTypeName) {
+                pd.namedTypeBaseTable[identifier] = mson::parseBaseType(typeDefinition.typeSpecification.name.base);
+            }
+            else if (!typeDefinition.typeSpecification.name.symbol.literal.empty() &&
+                     !typeDefinition.typeSpecification.name.symbol.variable) {
+
+                pd.namedTypeInheritanceTable[identifier] = typeDefinition.typeSpecification.name.symbol.literal;
+            }
+            else if (typeDefinition.typeSpecification.name.empty()) {
+
+                // If there is no specification, an object is assumed
+                pd.namedTypeBaseTable[identifier] = mson::ImplicitObjectBaseType;
+            }
+        }
+
+        /**
+         * \brief Resolve named type base table entries from the named type inheritance table
+         *
+         * \param pd Section parser data
+         * \param report Parse report
+         */
+        static void resolveNamedTypeTables(SectionParserData& pd,
+                                           Report& report) {
+
+            mson::NamedTypeInheritanceTable::iterator it;
+            mson::NamedTypeBaseTable::iterator baseIt;
+
+            for (it = pd.namedTypeInheritanceTable.begin();
+                 it != pd.namedTypeInheritanceTable.end();
+                 it++) {
+
+                resolveNamedTypeTableEntry(pd, it->first, it->second, report);
+            }
+        }
+
+        /**
+         * \brief For each entry in the named type inheritance table, resolve the sub-type's base type recursively
+         *
+         * \param pd Section parser data
+         * \param subType The sub named type between the two
+         * \param superType The super named type between the two
+         * \param report Parse report
+         */
+        static void resolveNamedTypeTableEntry(SectionParserData& pd,
+                                               const mson::Literal& subType,
+                                               const mson::Literal& superType,
+                                               Report& report) {
+
+            mson::BaseType baseType;
+            mson::NamedTypeBaseTable::iterator it = pd.namedTypeBaseTable.find(subType);
+
+            // If the base table entry is already filled, nothing else to do
+            if (it != pd.namedTypeBaseTable.end()) {
+                return;
+            }
+
+            // Otherwise, get the base type from super type
+            it = pd.namedTypeBaseTable.find(superType);
+
+            // If super type is not already resolved, then it means that it is a sub type of something else
+            if (it == pd.namedTypeBaseTable.end()) {
+
+                // Try to get the super type of the current super type
+                mson::NamedTypeInheritanceTable::iterator inhIt = pd.namedTypeInheritanceTable.find(superType);
+
+                if (inhIt == pd.namedTypeInheritanceTable.end()) {
+
+                    // We cannot find the super type in inheritance table at all
+                    // and there is not base type table entry for it, so, the blueprint is wrong
+                    std::stringstream ss;
+                    ss << "unable to find named type '" << superType << "' in the whole document";
+
+                    report.error = Error(ss.str(), BusinessError, mdp::CharactersRangeSet());
+                    return;
+                }
+
+                // Recursively, try to get a base type for the current super type
+                resolveNamedTypeTableEntry(pd, superType, inhIt->second, report);
+
+                if (report.error.code != Error::OK) {
+                    return;
+                }
+
+                baseType = pd.namedTypeBaseTable.find(superType)->second;
+            }
+            else {
+                baseType = it->second;
+            }
+
+            pd.namedTypeBaseTable[subType] = baseType;
+        }
 
         static void parseMetadata(const MarkdownNodeIterator& node,
                                   SectionParserData& pd,
@@ -274,13 +512,28 @@ namespace snowcrash {
             }
         }
 
-        /** Finds a resource group inside an resource groups collection */
-        static ResourceGroupIterator findResourceGroup(const ResourceGroups& resourceGroups,
-                                                       const ResourceGroup& resourceGroup) {
+        /**
+         * \brief Check if a resource group already exists with the given name
+         *
+         * \param blueprint The blueprint which is formed until now
+         * \param name The resource group name to be checked
+         */
+        static bool isResourceGroupDuplicate(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 &&
+                    it->category == Element::ResourceGroupCategory &&
+                    it->attributes.name == name) {
+
+                    return true;
+                }
+            }
 
-            return std::find_if(resourceGroups.begin(),
-                                resourceGroups.end(),
-                                std::bind2nd(MatchName<ResourceGroup>(), resourceGroup));
+            return false;
         }
 
         /**
@@ -291,58 +544,62 @@ namespace snowcrash {
         static void checkLazyReferencing(SectionParserData& pd,
                                          const ParseResultRef<Blueprint>& out) {
 
-            Collection<SourceMap<ResourceGroup> >::iterator resourceGroupSourceMapIt;
+            Collection<SourceMap<Element> >::iterator elementSourceMapIt;
 
             if (pd.exportSourceMap()) {
-                resourceGroupSourceMapIt = out.sourceMap.resourceGroups.collection.begin();
+                elementSourceMapIt = out.sourceMap.content.elements().collection.begin();
             }
 
-            for (ResourceGroups::iterator resourceGroupIt = out.node.resourceGroups.begin();
-                 resourceGroupIt != out.node.resourceGroups.end();
-                 ++resourceGroupIt) {
+            for (Elements::iterator elementIt = out.node.content.elements().begin();
+                 elementIt != out.node.content.elements().end();
+                 ++elementIt) {
 
-                checkResourceLazyReferencing(*resourceGroupIt, resourceGroupSourceMapIt, pd, out);
+                if (elementIt->element == Element::CategoryElement) {
+                    checkResourceLazyReferencing(*elementIt, *elementSourceMapIt, pd, out);
+                }
 
                 if (pd.exportSourceMap()) {
-                    resourceGroupSourceMapIt++;
+                    elementSourceMapIt++;
                 }
             }
         }
 
         /** Traverses Resource Collection to resolve references with `Pending` state (Lazy referencing) */
-        static void checkResourceLazyReferencing(ResourceGroup& resourceGroup,
-                                                 Collection<SourceMap<ResourceGroup> >::iterator resourceGroupSourceMapIt,
+        static void checkResourceLazyReferencing(Element& element,
+                                                 SourceMap<Element>& elementSourceMap,
                                                  SectionParserData& pd,
                                                  const ParseResultRef<Blueprint>& out) {
 
-            Collection<SourceMap<Resource> >::iterator resourceSourceMapIt;
+            Collection<SourceMap<Element> >::iterator resourceElementSourceMapIt;
 
             if (pd.exportSourceMap()) {
-                resourceSourceMapIt = resourceGroupSourceMapIt->resources.collection.begin();
+                resourceElementSourceMapIt = elementSourceMap.content.elements().collection.begin();
             }
 
-            for (Resources::iterator resourceIt = resourceGroup.resources.begin();
-                 resourceIt != resourceGroup.resources.end();
-                 ++resourceIt) {
+            for (Elements::iterator resourceElementIt = element.content.elements().begin();
+                 resourceElementIt != element.content.elements().end();
+                 ++resourceElementIt) {
 
-                checkActionLazyReferencing(*resourceIt, resourceSourceMapIt, pd, out);
+                if (resourceElementIt->element == Element::ResourceElement) {
+                    checkActionLazyReferencing(resourceElementIt->content.resource, resourceElementSourceMapIt->content.resource, pd, out);
+                }
 
                 if (pd.exportSourceMap()) {
-                    resourceSourceMapIt++;
+                    resourceElementSourceMapIt++;
                 }
             }
         }
 
         /** Traverses Action Collection to resolve references with `Pending` state (Lazy referencing) */
         static void checkActionLazyReferencing(Resource& resource,
-                                               Collection<SourceMap<Resource> >::iterator resourceSourceMapIt,
+                                               SourceMap<Resource>& resourceSourceMap,
                                                SectionParserData& pd,
                                                const ParseResultRef<Blueprint>& out) {
 
             Collection<SourceMap<Action> >::iterator actionSourceMapIt;
 
             if (pd.exportSourceMap()) {
-                actionSourceMapIt = resourceSourceMapIt->actions.collection.begin();
+                actionSourceMapIt = resourceSourceMap.actions.collection.begin();
             }
 
             for (Actions::iterator actionIt = resource.actions.begin();
@@ -404,14 +661,14 @@ namespace snowcrash {
                     if (pd.exportSourceMap()) {
 
                         ParseResultRef<Payload> payload(out.report, *requestIt, *requestSourceMapIt);
-                        resolvePendingSymbols(pd, payload);
+                        resolvePendingModels(pd, payload);
                         SectionProcessor<Payload>::checkRequest(requestIt->reference.meta.node, pd, payload);
                     }
                     else {
 
                         SourceMap<Payload> tempSourceMap;
                         ParseResultRef<Payload> payload(out.report, *requestIt, tempSourceMap);
-                        resolvePendingSymbols(pd, payload);
+                        resolvePendingModels(pd, payload);
                         SectionProcessor<Payload>::checkRequest(requestIt->reference.meta.node, pd, payload);
                     }
                 }
@@ -444,14 +701,14 @@ namespace snowcrash {
                     if (pd.exportSourceMap()) {
 
                         ParseResultRef<Payload> payload(out.report, *responseIt, *responseSourceMapIt);
-                        resolvePendingSymbols(pd, payload);
+                        resolvePendingModels(pd, payload);
                         SectionProcessor<Payload>::checkResponse(responseIt->reference.meta.node, pd, payload);
                     }
                     else {
 
                         SourceMap<Payload> tempSourceMap;
                         ParseResultRef<Payload> payload(out.report, *responseIt, tempSourceMap);
-                        resolvePendingSymbols(pd, payload);
+                        resolvePendingModels(pd, payload);
                         SectionProcessor<Payload>::checkResponse(responseIt->reference.meta.node, pd, payload);
                     }
                 }
@@ -463,21 +720,21 @@ namespace snowcrash {
         }
 
         /**
-         *  \brief  Resolve pending references
-         *  \param  pd       Section parser state
+         *  \brief  Resolve pending model references
+         *  \param  pd       Section parser data
          *  \param  out      Processed output
          */
-        static void resolvePendingSymbols(SectionParserData& pd,
+        static void resolvePendingModels(SectionParserData& pd,
                                           const ParseResultRef<Payload>& out) {
 
-            if (pd.symbolTable.resourceModels.find(out.node.reference.id) == pd.symbolTable.resourceModels.end()) {
+            if (pd.modelTable.find(out.node.reference.id) == pd.modelTable.end()) {
 
-                // ERR: Undefined symbol
+                // ERR: Undefined model reference
                 std::stringstream ss;
-                ss << "Undefined symbol " << out.node.reference.id;
+                ss << "Undefined resource model " << out.node.reference.id;
 
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(out.node.reference.meta.node->sourceMap, pd.sourceData);
-                out.report.error = Error(ss.str(), SymbolError, sourceMap);
+                out.report.error = Error(ss.str(), ModelError, sourceMap);
 
                 out.node.reference.meta.state = Reference::StateUnresolved;
             }