redsnow 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7a42395c3a357bc8d783eeafe217eb8169bf802
-  data.tar.gz: c3272147eb4b1ac934b7b675e38f216e5011941b
+  metadata.gz: a87a6fa01c627672f57d9c43bd053eb472bf34f5
+  data.tar.gz: 50f8b9c504bbb3450a1ec6eaebb261beb92e9e31
 SHA512:
-  metadata.gz: d4afc5e2fe580a75423a59ea58a8c5846562f23f73d20a6657d6f09c9c953599af1783304be443daa0619613e2969e66481f8173fac83e64cb19ff75ac284f8d
-  data.tar.gz: 1125f2f86362bd272e5da418e7b3cca2462a52a05dd0374c91d3042f9341b8b38e769289bc1f85f7d1f5a514502f9827bf629cd682ede49b4b7bc371385d8b70
+  metadata.gz: e5a8649d40c41d014156a6d325e9f1fa448f988a6b3a0da550edef1902a2423f1cf5a083caaf3233dea1975fe3065b82eab03822fd7def00a9c8182a98016397
+  data.tar.gz: 065df0a1d76038edff0dfe5f6b81b059af0938b4c5ac984777e74270123fa381b372a40be56aea1762bee0ed76e95bd02de356d2bb2ecb9a0ffa9c3f46d06441

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redsnow (0.4.0)
+    redsnow (0.4.1)
       bundler (>= 1.7.0)
       ffi (~> 1.9.3)
       rake (>= 10.3.2)
@@ -23,9 +23,9 @@ GEM
     celluloid (0.16.0)
       timers (~> 4.0.0)
     coderay (1.1.0)
-    ffi (1.9.6)
+    ffi (1.9.8)
     formatador (0.2.5)
-    guard (2.11.1)
+    guard (2.12.5)
       formatador (>= 0.2.4)
       listen (~> 2.7)
       lumberjack (~> 1.0)
@@ -39,8 +39,8 @@ GEM
       rubocop (~> 0.20)
     hitimes (1.2.2)
     i18n (0.7.0)
-    listen (2.8.5)
-      celluloid (>= 0.15.2)
+    listen (2.10.0)
+      celluloid (~> 0.16.0)
       rb-fsevent (>= 0.9.3)
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
@@ -49,14 +49,14 @@ GEM
     minitest (4.7.5)
     mocha (1.1.0)
       metaclass (~> 0.0.1)
-    multi_json (1.10.1)
+    multi_json (1.11.0)
     nenv (0.2.0)
-    notiffany (0.0.3)
+    notiffany (0.0.6)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    parser (2.2.0.2)
+    parser (2.2.2.1)
       ast (>= 1.1, < 3.0)
-    powerpack (0.0.9)
+    powerpack (0.1.0)
     pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
@@ -66,29 +66,29 @@ GEM
     rb-fsevent (0.9.4)
     rb-inotify (0.9.5)
       ffi (>= 0.5.0)
-    rubocop (0.28.0)
+    rubocop (0.30.1)
       astrolabe (~> 1.3)
-      parser (>= 2.2.0.pre.7, < 3.0)
-      powerpack (~> 0.0.6)
+      parser (>= 2.2.2.1, < 3.0)
+      powerpack (~> 0.1)
       rainbow (>= 1.99.1, < 3.0)
       ruby-progressbar (~> 1.4)
-    ruby-progressbar (1.7.1)
+    ruby-progressbar (1.7.5)
     shellany (0.0.1)
     shoulda (3.5.0)
       shoulda-context (~> 1.0, >= 1.0.1)
       shoulda-matchers (>= 1.4.1, < 3.0)
     shoulda-context (1.2.1)
-    shoulda-matchers (2.7.0)
+    shoulda-matchers (2.8.0)
       activesupport (>= 3.0.0)
     slop (3.6.0)
     thor (0.19.1)
-    thread_safe (0.3.4)
+    thread_safe (0.3.5)
     timers (4.0.1)
       hitimes
     turn (0.9.7)
       ansi
       minitest (~> 4)
-    tzinfo (0.3.42)
+    tzinfo (0.3.43)
     unindent (1.0)
     yard (0.8.7.6)
 

data/ext/drafter/configure

@@ -8,7 +8,7 @@
 import sys
 
 
-if sys.version_info.major != 2:
+if sys.version_info[0] != 2:
     # Since various Linux distros and OS X doesn't properly follow PEP 394,
     # We've set the shebang line to `python` and erroring when it isn't
     # Python 2.

data/ext/drafter/ext/snowcrash/configure

@@ -9,7 +9,7 @@
 import sys
 
 
-if sys.version_info.major != 2:
+if sys.version_info[0] != 2:
     # Since various Linux distros and OS X doesn't properly follow PEP 394,
     # We've set the shebang line to `python` and erroring when it isn't
     # Python 2.

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

@@ -9,6 +9,8 @@
 #ifndef SNOWCRASH_BLUEPRINTPARSER_H
 #define SNOWCRASH_BLUEPRINTPARSER_H
 
+#include <iterator>
+#include <algorithm>
 #include "ResourceParser.h"
 #include "ResourceGroupParser.h"
 #include "DataStructureGroupParser.h"
@@ -284,16 +286,14 @@ namespace snowcrash {
 
                 // ERR: No API name specified
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                out.report.error = Error(ExpectedAPINameMessage,
-                                         BusinessError,
-                                         sourceMap);
+                out.report.error = Error(ExpectedAPINameMessage, BusinessError, sourceMap);
 
             }
             else if (!out.node.description.empty()) {
+
+                // WARN: No API name specified
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
-                out.report.warnings.push_back(Warning(ExpectedAPINameMessage,
-                                                      APINameWarning,
-                                                      sourceMap));
+                out.report.warnings.push_back(Warning(ExpectedAPINameMessage, APINameWarning, sourceMap));
             }
         }
 
@@ -343,21 +343,47 @@ namespace snowcrash {
                 identifier = signature.identifier;
             }
 
-            // If named type already exists, do nothing
-            mson::NamedTypeBaseTable::iterator it = pd.namedTypeBaseTable.find(identifier);
+            // If named type already exists, return error
+            if (pd.namedTypeDependencyTable.find(identifier) != pd.namedTypeDependencyTable.end()) {
 
-            if (it != pd.namedTypeBaseTable.end()) {
+                // ERR: Named type is defined more than once
+                std::stringstream ss;
+                ss << "named type '" << identifier << "' is defined more than once";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+                report.error = Error(ss.str(), MSONError, sourceMap);
                 return;
             }
 
-            // Otherwise, add the respective entries to the tables
-            if (typeDefinition.typeSpecification.name.base != mson::UndefinedTypeName) {
+            mson::BaseTypeName baseTypeName = typeDefinition.typeSpecification.name.base;
+
+            // Initialize an entry in the dependency table
+            pd.namedTypeDependencyTable[identifier] = std::set<mson::Literal>();
+
+            // Add the respective entries to the tables
+            if (baseTypeName != mson::UndefinedTypeName) {
                 pd.namedTypeBaseTable[identifier] = mson::parseBaseType(typeDefinition.typeSpecification.name.base);
+
+                // Add nested types as dependents
+                if (baseTypeName == mson::ArrayTypeName || baseTypeName == mson::EnumTypeName) {
+
+                    for (mson::TypeNames::iterator it = typeDefinition.typeSpecification.nestedTypes.begin();
+                         it != typeDefinition.typeSpecification.nestedTypes.end();
+                         ++it) {
+
+                        if (!it->symbol.literal.empty() && !it->symbol.variable) {
+                            pd.namedTypeDependencyTable[identifier].insert(it->symbol.literal);
+                        }
+                    }
+                }
             }
             else if (!typeDefinition.typeSpecification.name.symbol.literal.empty() &&
                      !typeDefinition.typeSpecification.name.symbol.variable) {
 
-                pd.namedTypeInheritanceTable[identifier] = typeDefinition.typeSpecification.name.symbol.literal;
+                pd.namedTypeInheritanceTable[identifier] = std::make_pair(typeDefinition.typeSpecification.name.symbol.literal, node->sourceMap);
+
+                // Make the sub type dependent on super type
+                pd.namedTypeDependencyTable[identifier].insert(typeDefinition.typeSpecification.name.symbol.literal);
             }
             else if (typeDefinition.typeSpecification.name.empty()) {
 
@@ -376,16 +402,62 @@ namespace snowcrash {
                                            Report& report) {
 
             mson::NamedTypeInheritanceTable::iterator it;
-            mson::NamedTypeBaseTable::iterator baseIt;
+            mson::NamedTypeDependencyTable::iterator depIt;
+
+            // First resolve dependency tables
+            for (depIt = pd.namedTypeDependencyTable.begin();
+                 depIt != pd.namedTypeDependencyTable.end();
+                 depIt++) {
+
+                resolveNamedTypeDependencyTableEntry(pd, depIt->first, report);
+            }
 
             for (it = pd.namedTypeInheritanceTable.begin();
                  it != pd.namedTypeInheritanceTable.end();
                  it++) {
 
-                resolveNamedTypeTableEntry(pd, it->first, it->second, report);
+                resolveNamedTypeBaseTableEntry(pd, it->first, it->second.first, it->second.second, report);
+
+                if (report.error.code != Error::OK) {
+                    return;
+                }
             }
         }
 
+        /**
+         * \brief Resolve the inheritance dependencies of the current named type
+         *        (Does not include mixin or member dependencies)
+         *
+         * \param pd Section parser data
+         * \param identifier The named type whose dependents need to be resolved
+         * \param report Parse report
+         */
+        static void resolveNamedTypeDependencyTableEntry(SectionParserData& pd,
+                                                         const mson::Literal& identifier,
+                                                         Report& report) {
+
+            std::set<mson::Literal> diffDeps, finalDeps, initialDeps;
+
+            do {
+                initialDeps = pd.namedTypeDependencyTable[identifier];
+                diffDeps.clear();
+
+                for (std::set<mson::Literal>::iterator it = initialDeps.begin();
+                     it != initialDeps.end();
+                     it++) {
+
+                    std::set<mson::Literal> superTypeDeps = pd.namedTypeDependencyTable[*it];
+                    pd.namedTypeDependencyTable[identifier].insert(superTypeDeps.begin(), superTypeDeps.end());
+                }
+
+                // Check if the list of dependents has grown
+                finalDeps = pd.namedTypeDependencyTable[identifier];
+                std::set_difference(finalDeps.begin(), finalDeps.end(), initialDeps.begin(), initialDeps.end(),
+                                    std::inserter(diffDeps, diffDeps.end()));
+
+            } while (!diffDeps.empty());
+        };
+
         /**
          * \brief For each entry in the named type inheritance table, resolve the sub-type's base type recursively
          *
@@ -394,10 +466,11 @@ namespace snowcrash {
          * \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) {
+        static void resolveNamedTypeBaseTableEntry(SectionParserData& pd,
+                                                   const mson::Literal& subType,
+                                                   const mson::Literal& superType,
+                                                   const mdp::BytesRangeSet& nodeSourceMap,
+                                                   Report& report) {
 
             mson::BaseType baseType;
             mson::NamedTypeBaseTable::iterator it = pd.namedTypeBaseTable.find(subType);
@@ -407,6 +480,20 @@ namespace snowcrash {
                 return;
             }
 
+            // Check for circular references
+            std::set<mson::Literal> deps = pd.namedTypeDependencyTable[subType];
+
+            if (deps.find(subType) != deps.end()) {
+
+                // ERR: A named type is circularly referenced
+                std::stringstream ss;
+                ss << "base type '" << subType << "' circularly referencing itself";
+
+                mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(nodeSourceMap, pd.sourceData);
+                report.error = Error(ss.str(), MSONError, sourceMap);
+                return;
+            }
+
             // Otherwise, get the base type from super type
             it = pd.namedTypeBaseTable.find(superType);
 
@@ -416,19 +503,21 @@ namespace snowcrash {
                 // Try to get the super type of the current super type
                 mson::NamedTypeInheritanceTable::iterator inhIt = pd.namedTypeInheritanceTable.find(superType);
 
+                // Check for recursive MSON definitions
                 if (inhIt == pd.namedTypeInheritanceTable.end()) {
 
-                    // We cannot find the super type in inheritance table at all
+                    // ERR: 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";
+                    ss << "base type '" << superType << "' is not defined in the document";
 
-                    report.error = Error(ss.str(), BusinessError, mdp::CharactersRangeSet());
+                    mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(nodeSourceMap, pd.sourceData);
+                    report.error = Error(ss.str(), MSONError, sourceMap);
                     return;
                 }
 
                 // Recursively, try to get a base type for the current super type
-                resolveNamedTypeTableEntry(pd, superType, inhIt->second, report);
+                resolveNamedTypeBaseTableEntry(pd, superType, inhIt->second.first, inhIt->second.second, report);
 
                 if (report.error.code != Error::OK) {
                     return;

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

@@ -11,6 +11,7 @@
 
 #include <vector>
 #include <string>
+#include <set>
 #include <map>
 #include <stdexcept>
 
@@ -54,7 +55,10 @@ namespace mson {
     typedef std::map<Literal, BaseType> NamedTypeBaseTable;
 
     /** Named Types inheritance table */
-    typedef std::map<Literal, Literal> NamedTypeInheritanceTable;
+    typedef std::map<Literal, std::pair<Literal, mdp::BytesRangeSet> > NamedTypeInheritanceTable;
+
+    /** Named Types dependency table */
+    typedef std::map<Literal, std::set<Literal> > NamedTypeDependencyTable;
 
     /** A simple or actual value */
     struct Value {

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

@@ -65,6 +65,14 @@ namespace snowcrash {
                                                       sourceMap));
             }
 
+            // Check circular references
+            if (out.node.typeSpecification.name.base == mson::UndefinedTypeName &&
+                !out.node.typeSpecification.name.symbol.literal.empty() &&
+                !out.node.typeSpecification.name.symbol.variable) {
+
+                mson::addDependency(node, pd, out.node.typeSpecification.name.symbol.literal, pd.namedTypeContext, out.report);
+            }
+
             return ++MarkdownNodeIterator(node);
         }
 

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

@@ -34,7 +34,7 @@ namespace snowcrash {
                                                       const Signature& signature,
                                                       const ParseResultRef<mson::NamedType>& out) {
 
-            mson::parseTypeName(signature.identifier, out.node.name);
+            mson::parseTypeName(signature.identifier, out.node.name, false);
             mson::parseTypeDefinition(node, pd, signature.attributes, out.report, out.node.typeDefinition);
 
             if (pd.exportSourceMap()) {
@@ -53,6 +53,9 @@ namespace snowcrash {
                 out.node.typeDefinition.baseType = mson::ImplicitObjectBaseType;
             }
 
+            // Setup named type context
+            pd.namedTypeContext = out.node.name.symbol.literal;
+
             return ++MarkdownNodeIterator(node);
         }
 
@@ -99,6 +102,14 @@ namespace snowcrash {
 
             return SectionProcessor<mson::ValueMember>::nestedSectionType(node);
         }
+
+        static void finalize(const MarkdownNodeIterator& node,
+                             SectionParserData& pd,
+                             const ParseResultRef<mson::NamedType>& out) {
+
+            // Clear named type context
+            pd.namedTypeContext.clear();
+        }
     };
 
     /** MSON Named Type Section Parser */

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

@@ -121,26 +121,28 @@ namespace mson {
      *
      * \param subject String which represents the type name
      * \param typeName MSON Type Name
+     * \param isBaseType If false, will be parsed as a symbol
      */
     inline void parseTypeName(const std::string& subject,
-                              TypeName& typeName) {
+                              TypeName& typeName,
+                              bool isBaseType = true) {
 
-        if (subject == "boolean") {
+        if (isBaseType && subject == "boolean") {
             typeName.base = BooleanTypeName;
         }
-        else if (subject == "string") {
+        else if (isBaseType && subject == "string") {
             typeName.base = StringTypeName;
         }
-        else if (subject == "number") {
+        else if (isBaseType && subject == "number") {
             typeName.base = NumberTypeName;
         }
-        else if (subject == "array") {
+        else if (isBaseType && subject == "array") {
             typeName.base = ArrayTypeName;
         }
-        else if (subject == "enum") {
+        else if (isBaseType && subject == "enum") {
             typeName.base = EnumTypeName;
         }
-        else if (subject == "object") {
+        else if (isBaseType && subject == "object") {
             typeName.base = ObjectTypeName;
         }
         else {
@@ -418,6 +420,66 @@ namespace mson {
             propertyName.literal = subject;
         }
     }
+
+    /**
+     * \brief Add a dependency to the dependency list of the dependents while checking for circular references
+     *
+     * \param node Current markdown node iterator
+     * \param pd Section parser data
+     * \param dependency The named type which should be added to the dependency list
+     * \param dependent The named type to which the dependency should be added
+     * \param report Parse result report
+     */
+    inline void addDependency(const mdp::MarkdownNodeIterator& node,
+                              snowcrash::SectionParserData& pd,
+                              const mson::Literal dependency,
+                              const mson::Literal dependent,
+                              snowcrash::Report& report) {
+
+        // First, check if the type exists
+        if (pd.namedTypeDependencyTable.find(dependency) == pd.namedTypeDependencyTable.end()) {
+
+            // ERR: We cannot find the dependency type
+            std::stringstream ss;
+            ss << "base type '" << dependency << "' is not defined in the document";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.error = snowcrash::Error(ss.str(), snowcrash::MSONError, sourceMap);
+            return;
+        }
+
+        std::set<mson::Literal> dependencyDeps = pd.namedTypeDependencyTable[dependency];
+
+        // Second, check if it is circular reference between them
+        if (dependent == dependency ||
+            dependencyDeps.find(dependent) != dependencyDeps.end()) {
+
+            // ERR: Dependency named type circular references itself
+            std::stringstream ss;
+            ss << "base type '" << dependent << "' circularly referencing itself";
+
+            mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
+            report.error = snowcrash::Error(ss.str(), snowcrash::MSONError, sourceMap);
+            return;
+        }
+
+        // Third, check if the dependency is already in the list
+        if (pd.namedTypeDependencyTable[dependent].find(dependency) != pd.namedTypeDependencyTable[dependent].end()) {
+            return;
+        }
+
+        for (mson::NamedTypeDependencyTable::iterator it = pd.namedTypeDependencyTable.begin();
+             it != pd.namedTypeDependencyTable.end();
+             ++it) {
+
+            // If the entry is dependent itself or contain dependent in its list
+            if (it->first == dependent || it->second.find(dependent) != it->second.end()) {
+
+                it->second.insert(dependency);
+                it->second.insert(dependencyDeps.begin(), dependencyDeps.end());
+            }
+        }
+    }
 }
 
 #endif

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

@@ -111,6 +111,29 @@ namespace snowcrash {
             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) {

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

@@ -255,7 +255,7 @@ namespace snowcrash {
                 // ERR: unable to parse
                 mdp::CharactersRangeSet sourceMap = mdp::BytesRangeSetToCharactersRangeSet(node->sourceMap, pd.sourceData);
                 out.report.error = Error("unable to parse parameter specification",
-                                         BusinessError,
+                                         ApplicationError,
                                          sourceMap);
             }
         }
@@ -470,7 +470,13 @@ namespace snowcrash {
                     std::string first = innerSignature.substr(0, 1);
 
                     if (first == "`") {
-                        RetrieveEscaped(innerSignature);
+                        std::string escaped = RetrieveEscaped(innerSignature);
+
+                        // If empty value is returned
+                        if (escaped.empty()) {
+                            innerSignature.clear();
+                        }
+
                         TrimString(innerSignature);
                     }
                     else if (first == "(") {

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

@@ -105,9 +105,17 @@ namespace snowcrash {
 
                 case AttributesSectionType:
                 {
+                    // Set up named type context
+                    if (!out.node.name.empty()) {
+                        pd.namedTypeContext = out.node.name;
+                    }
+
                     ParseResultRef<Attributes> attributes(out.report, out.node.attributes, out.sourceMap.attributes);
                     MarkdownNodeIterator cur = AttributesParser::parse(node, siblings, pd, attributes);
 
+                    // Clear named type context
+                    pd.namedTypeContext.clear();
+
                     if (!out.node.name.empty()) {
 
                         if (SectionProcessor<DataStructureGroup>::isNamedTypeDuplicate(pd.blueprint, out.node.name)) {

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

@@ -51,6 +51,12 @@ namespace snowcrash {
         /** Table mapping named type to sub types */
         mson::NamedTypeInheritanceTable namedTypeInheritanceTable;
 
+        /** Table mapping named types to their dependent named types */
+        mson::NamedTypeDependencyTable namedTypeDependencyTable;
+
+        /** Variable to store the current named type */
+        mson::Literal namedTypeContext;
+
         /** Model Table */
         ModelTable modelTable;
 

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

@@ -371,13 +371,15 @@ namespace scpl {
          * \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
+         * \param clearAtEnd If this is true, the string will be cleared at the end of parsing
          *
          * \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) {
+                                             const bool splitByAttribute = false,
+                                             const bool clearAtEnd = false) {
 
             size_t i = begin + 1;
             mdp::ByteBuffer returnString;
@@ -403,11 +405,11 @@ namespace scpl {
                     }
                 } else if (subject[i] == '[') {
 
-                    returnString += matchBrackets(subject, i, ']');
+                    returnString += matchBrackets(subject, i, ']', false, true);
                     i = 0;
                 } else if (subject[i] == '(') {
 
-                    returnString += matchBrackets(subject, i, ')');
+                    returnString += matchBrackets(subject, i, ')', false, true);
                     i = 0;
                 } else if (subject[i] == endBracket) {
 
@@ -431,6 +433,10 @@ namespace scpl {
                 }
             }
 
+            if (i == subject.length() && clearAtEnd) {
+                subject.clear();
+            }
+
             return returnString;
         }
     };

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

@@ -101,7 +101,8 @@ namespace snowcrash {
         NoError = 0,
         ApplicationError = 1,
         BusinessError = 2,
-        ModelError = 3
+        ModelError = 3,
+        MSONError = 4
     };
 
     /**

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

@@ -188,7 +188,7 @@ void URITemplateParser::parse(const URITemplate& uri, const mdp::CharactersRange
         }
     }
     else{
-        result.report.error = Error("Failed to parse URI Template", URIWarning);
+        result.report.error = Error("Failed to parse URI Template", ApplicationError);
     }
 
 }

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

@@ -76,11 +76,11 @@ int snowcrash::parse(const mdp::ByteBuffer& source,
 
         std::stringstream ss;
         ss << "parser exception: '" << e.what() << "'";
-        out.report.error = Error(ss.str(), 1);
+        out.report.error = Error(ss.str(), ApplicationError);
     }
     catch (...) {
 
-        out.report.error = Error("parser exception has occured", 1);
+        out.report.error = Error("parser exception has occured", ApplicationError);
     }
 
     return out.report.error.code;

data/ext/drafter/src/Version.h

@@ -15,7 +15,7 @@
 
 #define DRAFTER_MAJOR_VERSION 0
 #define DRAFTER_MINOR_VERSION 1
-#define DRAFTER_PATCH_VERSION 0
+#define DRAFTER_PATCH_VERSION 5
 
 #define DRAFTER_VERSION_IS_RELEASE 1
 

data/ext/drafter/src/main.cc

@@ -72,14 +72,14 @@ int main(int argc, const char *argv[])
     if (!config.validate) {  // not just validate -> we will serialize
         sos::Serialize* serializer = CreateSerializer(config.format);
 
-        Serialization(CreateStreamFromName<std::ostream>(config.output),
-                      drafter::WrapBlueprint(blueprint.node), 
-                      serializer);
+        std::ostream *out = CreateStreamFromName<std::ostream>(config.output);
+        Serialization(out, drafter::WrapBlueprint(blueprint.node), serializer);
+        delete out;
 
         if (options & snowcrash::ExportSourcemapOption) {
-            Serialization(CreateStreamFromName<std::ostream>(config.sourceMap),
-                          drafter::WrapBlueprintSourcemap(blueprint.sourceMap),
-                          serializer);
+            std::ostream *sourcemap = CreateStreamFromName<std::ostream>(config.sourceMap);
+            Serialization(sourcemap, drafter::WrapBlueprintSourcemap(blueprint.sourceMap), serializer);
+            delete sourcemap;
         }
 
         delete serializer;

data/ext/drafter/tools/homebrew/drafter.rb

@@ -2,7 +2,7 @@ require 'formula'
 
 class Drafter < Formula
   homepage 'http://apiblueprint.org'
-  head 'https://github.com/apiaryio/drafter.git', :tag => 'v0.1.0'
+  head 'https://github.com/apiaryio/drafter.git', :tag => 'v0.1.5'
 
   def install
     system "./configure"

data/lib/redsnow.rb

@@ -10,8 +10,8 @@ module RedSnow
   include Binding
 
   # Options
-  EXPORT_SOURCEMAP_OPTION_KEY = :'exportSourcemap'
-  REQUIRE_BLUEPRINT_NAME_OPTION_KEY = :'requireBlueprintName'
+  EXPORT_SOURCEMAP_OPTION_KEY = :exportSourcemap
+  REQUIRE_BLUEPRINT_NAME_OPTION_KEY = :requireBlueprintName
 
   # Parse options
   attr_accessor :options

data/lib/redsnow/blueprint.rb

@@ -80,7 +80,7 @@ module RedSnow
     end
 
     def get_item(key)
-      @collection.select { |item| item[:name].downcase == key.downcase }.first
+      @collection.find { |item| item[:name].downcase == key.downcase }
     end
   end
 

data/lib/redsnow/version.rb

@@ -1,5 +1,5 @@
 # Module RedSnow
 module RedSnow
   # Gem version
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

data/redsnow.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |gem|
   gem.homepage      = 'https://github.com/apiaryio/redsnow'
   gem.license       = 'MIT'
   gem.files         = Dir['lib/**/*']
-  gem.files         << Dir['*']
-  gem.files         << Dir['ext/drafter/**/*'].reject { |f| f =~ /cmdline|test|features|README*|LICENSE|Gemfile*|\.xcode*/   }
+  gem.files << Dir['*']
+  gem.files << Dir['ext/drafter/**/*'].reject { |f| f =~ /cmdline|test|features|README*|LICENSE|Gemfile*|\.xcode*/   }
   gem.executables   = gem.files.grep(/^bin/).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(/^(test|spec|features)/)
   gem.require_paths = %w(lib ext)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redsnow
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Ladislav Prskavec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2015-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -443,7 +443,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Ruby bindings for Snow Crash