lounge_lizard 0.1.0

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

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

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

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

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

@@ -0,0 +1,87 @@
+//
+//  ModelTable.h
+//  snowcrash
+//
+//  Created by Zdenek Nemec on 6/9/13.
+//  Copyright (c) 2013 Apiary Inc. All rights reserved.
+//
+
+#ifndef SNOWCRASH_MODELTABLE_H
+#define SNOWCRASH_MODELTABLE_H
+
+#include <string>
+#include <map>
+#include "ByteBuffer.h"
+#include "RegexMatch.h"
+
+#ifdef DEBUG
+#include <iostream>
+#endif
+
+#include "BlueprintSourcemap.h"
+#include "StringUtility.h"
+
+// Symbol identifier regex
+#define SYMBOL_IDENTIFIER "([^][()]+)"
+
+namespace snowcrash {
+
+    /** Symbol reference matching regex */
+    const char* const ModelReferenceRegex("^[[:blank:]]*\\[" SYMBOL_IDENTIFIER "]\\[][[:blank:]]*$");
+
+    // Resource Object Model Table
+    typedef std::map<Identifier, ResourceModel> ModelTable;
+
+    // Resource Object Model Table source map
+    typedef std::map<Identifier, SourceMap<ResourceModel> > ModelSourceMapTable;
+
+    // Checks whether given source data represents reference to a symbol returning true if so,
+    // false otherwise. If source data is represent reference referred symbol name is filled in.
+    inline bool GetModelReference(const mdp::ByteBuffer& sourceData,
+                                   Identifier& referredModel) {
+
+        CaptureGroups captureGroups;
+
+        if (RegexCapture(sourceData, ModelReferenceRegex, captureGroups, 3)) {
+            referredModel = captureGroups[1];
+            TrimString(referredModel);
+            return true;
+        }
+
+        return false;
+    }
+
+#ifdef DEBUG
+    // Escape new lines
+    inline std::string EscapeNewlines(const std::string &input) {
+
+        size_t pos = 0;
+        std::string target(input);
+
+        while ((pos = target.find("\n", pos)) != std::string::npos) {
+            target.replace(pos, 1, "\\n");
+            pos += 2;
+        }
+
+        return target;
+    }
+
+    // Prints markdown block recursively to stdout
+    inline void PrintModelTable(const ModelTable& modelTable) {
+
+        std::cout << "Resource Model Symbols:\n";
+
+        for (ModelTable::const_iterator it = modelTable.begin();
+             it != modelTable.end();
+             ++it) {
+
+            std::cout << "- " << it->first << " - body: '" << EscapeNewlines(it->second.body) << "'\n";
+        }
+
+        std::cout << std::endl;
+    }
+#endif
+
+}
+
+#endif