redsnow 0.2.1 → 0.3.0

data/ext/snowcrash/src/StringUtility.h

@@ -33,18 +33,18 @@ namespace snowcrash {
         s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun(isSpace))));
         return s;
     }
-    
+
     // Trim string from end
     inline std::string& TrimStringEnd(std::string &s) {
         s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun(isSpace))).base(), s.end());
         return s;
     }
-    
+
     // Trim both ends of string
     inline std::string& TrimString(std::string &s) {
         return TrimStringStart(TrimStringEnd(s));
     }
-    
+
     // Split string by delim
     inline std::vector<std::string>& Split(const std::string& s, char delim, std::vector<std::string>& elems) {
         std::stringstream ss(s);
@@ -54,14 +54,14 @@ namespace snowcrash {
         }
         return elems;
     }
-    
-    // Split string by delim    
+
+    // Split string by delim
     inline std::vector<std::string> Split(const std::string& s, char delim) {
         std::vector<std::string> elems;
         Split(s, delim, elems);
         return elems;
     }
-    
+
     // Split string on the first occurrence of delim
     inline std::vector<std::string> SplitOnFirst(const std::string& s, char delim) {
         std::string::size_type pos = s.find(delim);
@@ -75,7 +75,7 @@ namespace snowcrash {
         }
         return elems;
     }
-    
+
     // Make sure last two characters are newlines
     inline std::string& TwoNewLines(std::string& s) {
 
@@ -108,10 +108,10 @@ namespace snowcrash {
         }
         return target;
     }
-    
+
     /**
      *  \brief  Extract the first line from a string.
-     *  
+     *
      *  \param  s   Subject of the extraction
      *  \param  r   Remaining content aftert the extraction
      *  \return First line from the subject string
@@ -124,6 +124,68 @@ namespace snowcrash {
             r = elem.back();
         return elem.front();
     }
+
+
+    /**
+     *  \brief  compare equality  - allow compare diferent types
+     *
+     *  \return true if args era equal
+     */
+    struct IsEqual {
+        template<typename T1, typename T2>
+            bool operator()(const T1& a1, const T2& a2) const {
+                return a1 == a2;
+            }
+    };
+
+    /**
+     *  \brief  compare equality - character are compare case insensitive
+     *
+     *  \return true if args era equal
+     */
+    struct IsIEqual {
+        template<typename T1, typename T2>
+            bool operator()(const T1& a1, const T2& a2) const {
+                return std::tolower(a1) == std::tolower(a2);
+            }
+    };
+
+    /**
+     *  \brief  compare containers equality 
+     *
+     *  \requirements 
+     *    - both containers must support methods ::length(), ::begin(), ::end()
+     *    - both containers must be iterable
+     *    - both containers must contain comparable types
+     *
+     *  \param arg1, arg2 - containers to compare
+     *  \param predicate - testing equality
+     *
+     *  \return true if containers contains same content
+     */
+
+    template <typename T1, typename T2, typename Predicate>
+    inline bool MatchContainers(const T1& arg1, const T2& arg2, const Predicate& predicate) {
+        if (arg1.length() != arg2.length()) {
+            return false;
+        }
+        return std::equal(arg1.begin(), arg1.end(), arg2.begin(), predicate);
+    }
+    
+    template <typename T>
+    struct Equal : std::binary_function<T, T, bool> {
+        bool operator()(const T& left, const T& right) const {
+            return MatchContainers(left, right, IsEqual());
+        }
+    };
+
+    template <typename T>
+    struct IEqual : std::binary_function<T, T, bool> {
+        bool operator()(const T& left, const T& right) const {
+            return MatchContainers(left, right, IsIEqual());
+        }
+    };
+
 }
 
 #endif

data/ext/snowcrash/src/SymbolTable.h

@@ -26,42 +26,42 @@
 #define SYMBOL_IDENTIFIER "([^][()]+)"
 
 namespace snowcrashconst {
-    
+
     /** Symbol reference matching regex */
     const char* const SymbolReferenceRegex("^[[:blank:]]*\\[" SYMBOL_IDENTIFIER "]\\[][[:blank:]]*$");
 }
 
 namespace snowcrash {
-    
+
     // Resource Object Symbol
-    typedef std::pair<SymbolName, ResourceModel> ResourceModelSymbol;
+    typedef std::pair<Identifier, ResourceModel> ResourceModelSymbol;
 
     // Resource Object Symbol source map
-    typedef std::pair<SymbolName, SourceMap<ResourceModel> > ResourceModelSymbolSourceMap;
+    typedef std::pair<Identifier, SourceMap<ResourceModel> > ResourceModelSymbolSourceMap;
 
     // Resource Object Symbol Table
-    typedef std::map<SymbolName, ResourceModel> ResourceModelSymbolTable;
-    
-    // Reesource Object Symbol Table source map
-    typedef std::map<SymbolName, SourceMap<ResourceModel> > ResourceModelSymbolSourceMapTable;
+    typedef std::map<Identifier, ResourceModel> ResourceModelSymbolTable;
+
+    // Resource Object Symbol Table source map
+    typedef std::map<Identifier, SourceMap<ResourceModel> > ResourceModelSymbolSourceMapTable;
 
     struct SymbolTable {
-        
+
         // Resource Object Symbol Table
         ResourceModelSymbolTable resourceModels;
     };
-    
+
     struct SymbolSourceMapTable {
 
         // Resource Object Symbol Table source map
         ResourceModelSymbolSourceMapTable resourceModels;
     };
-    
+
     // 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 GetSymbolReference(const mdp::ByteBuffer& sourceData,
-                                   SymbolName& referredSymbol) {
-        
+                                   Identifier& referredSymbol) {
+
         CaptureGroups captureGroups;
 
         if (RegexCapture(sourceData, snowcrashconst::SymbolReferenceRegex, captureGroups, 3)) {
@@ -72,7 +72,7 @@ namespace snowcrash {
 
         return false;
     }
-    
+
 #ifdef DEBUG
     // Prints markdown block recursively to stdout
     inline void PrintSymbolTable(const SymbolTable& symbolTable) {
@@ -81,14 +81,14 @@ namespace snowcrash {
         for (ResourceModelSymbolTable::const_iterator it = symbolTable.resourceModels.begin();
              it != symbolTable.resourceModels.end();
              ++it) {
-            
+
             std::cout << "- " << it->first << " - body: '" << EscapeNewlines(it->second.body) << "'\n";
         }
-        
+
         std::cout << std::endl;
     }
 #endif
-    
+
 }
 
 #endif

data/ext/snowcrash/src/UriTemplateParser.cc

@@ -53,7 +53,7 @@ static Expressions GetUriTemplateExpressions(const URITemplate& uriTemplate) {
     Expressions expressions;
     size_t expressionStartPos = 0;
     size_t expressionEndPos = 0;
-    
+
     while (expressionStartPos != std::string::npos && expressionEndPos != std::string::npos && expressionStartPos < uriTemplate.length()) {
         expressionStartPos = uriTemplate.find("{", expressionStartPos);
         expressionEndPos = uriTemplate.find("}", expressionStartPos);
@@ -105,12 +105,12 @@ static ClassifiedExpression ClassifyExpression(const Expression& expression) {
     }
 
     FormStyleQueryContinuationExpression formStyleQueryContinuationExpression(expression);
-    if (formStyleQueryContinuationExpression.IsExpressionType()) { 
+    if (formStyleQueryContinuationExpression.IsExpressionType()) {
         return formStyleQueryContinuationExpression;
     }
 
     UndefinedExpression undefinedExpression(expression);
-    
+
     return undefinedExpression;
 }
 
@@ -131,7 +131,7 @@ void URITemplateParser::parse(const URITemplate& uri, const mdp::CharactersRange
             result.report.warnings.push_back(Warning("The URI template contains mismatched expression brackets", URIWarning, sourceBlock));
             return;
         }
-       
+
         if (HasNestedCurlyBrackets(result.path)) {
             result.report.warnings.push_back(Warning("The URI template contains nested expression brackets", URIWarning, sourceBlock));
             return;
@@ -172,7 +172,7 @@ void URITemplateParser::parse(const URITemplate& uri, const mdp::CharactersRange
                     result.report.warnings.push_back(Warning(ss.str(), URIWarning, sourceBlock));
                     hasIllegalCharacters = true;
                 }
-               
+
                 if (!hasIllegalCharacters) {
                     if (classifiedExpression.IsInvalidExpressionName()) {
                         std::stringstream ss;

data/ext/snowcrash/src/UriTemplateParser.h

@@ -18,7 +18,7 @@
 #define URI_TEMPLATE_EXPRESSION_REGEX "^([?|#|+|&]?(([A-Z|a-z|0-9|_|,])*|(%[A-F|a-f|0-9]{2})*)*\\*?)$"
 
 namespace snowcrash {
-    
+
     /**
     *  \brief URI template parse result.
     */
@@ -26,10 +26,10 @@ namespace snowcrash {
         std::string scheme;
         std::string host;
         std::string path;
-        
+
         Report report;
     };
-    
+
     /**
     *  \brief URI template expression.
     */
@@ -59,13 +59,13 @@ namespace snowcrash {
         }
 
         std::string unsupportedWarningText;
-        
+
         snowcrash::Expression innerExpression;
-        
+
         virtual bool IsExpressionType() const {
             return false;
         }
-                
+
         bool ContainsSpaces() {
             return innerExpression.find(" ") != std::string::npos;
         }
@@ -81,11 +81,11 @@ namespace snowcrash {
         bool IsInvalidExpressionName() {
             std::string tmpExpression = innerExpression;
             if (tmpExpression.find("..") != std::string::npos) return true;
-            
+
             size_t start_pos = 0;
             while ((start_pos = tmpExpression.find(".", start_pos)) != std::string::npos) {
                 tmpExpression.replace(start_pos, 1, "_");
-                start_pos++; 
+                start_pos++;
             }
 
             return !RegexMatch(tmpExpression, URI_TEMPLATE_EXPRESSION_REGEX);
@@ -193,7 +193,7 @@ namespace snowcrash {
             return innerExpression.substr(0, 1) == ";";
         }
     };
-   
+
     /**
     *  \brief level three form style query continuation expansion URI template expression.
     */

data/ext/snowcrash/src/ValuesParser.h

@@ -30,7 +30,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processNestedSection(const MarkdownNodeIterator& node,
                                                          const MarkdownNodes& siblings,
                                                          SectionParserData& pd,
-                                                         ParseResult<Values>& out) {
+                                                         const ParseResultRef<Values>& out) {
 
             if (pd.sectionContext() == ValueSectionType) {
 
@@ -70,7 +70,7 @@ namespace snowcrash {
         static MarkdownNodeIterator processDescription(const MarkdownNodeIterator& node,
                                                        const MarkdownNodes& siblings,
                                                        SectionParserData& pd,
-                                                       ParseResult<Values>& out) {
+                                                       const ParseResultRef<Values>& out) {
 
             return node;
         }

data/ext/snowcrash/src/Version.h

@@ -15,7 +15,7 @@
 #define SNOWCRASH_VERSION_H
 
 #define SNOWCRASH_MAJOR_VERSION 0
-#define SNOWCRASH_MINOR_VERSION 15
+#define SNOWCRASH_MINOR_VERSION 16
 #define SNOWCRASH_PATCH_VERSION 0
 
 #define SNOWCRASH_VERSION_IS_RELEASE 1

data/ext/snowcrash/src/csnowcrash.cc

@@ -9,19 +9,21 @@
 #include "csnowcrash.h"
 #include "snowcrash.h"
 
+using namespace snowcrash;
+
 int sc_c_parse(const char* source, sc_blueprint_parser_options option, sc_report_t** report, sc_blueprint_t** blueprint, sc_sm_blueprint_t** sm_blueprint)
 {
-    snowcrash::Report* t_report = ::new snowcrash::Report;
-    snowcrash::Blueprint* t_blueprint = ::new snowcrash::Blueprint;
-    snowcrash::SourceMap<snowcrash::Blueprint>* t_sm_blueprint = ::new snowcrash::SourceMap<snowcrash::Blueprint>;
+    Report* resultReport = ::new snowcrash::Report;
+    Blueprint* resultblueprint = ::new snowcrash::Blueprint;
+    SourceMap<snowcrash::Blueprint>* resultSourceMap = ::new SourceMap<snowcrash::Blueprint>;
 
-    snowcrash::ParseResult<snowcrash::Blueprint>* t_parse_result = ::new snowcrash::ParseResult<snowcrash::Blueprint>(*t_report, *t_blueprint, *t_sm_blueprint);
+    ParseResultRef<Blueprint> result(*resultReport, *resultblueprint, *resultSourceMap);
 
-    int ret = snowcrash::parse(source, option, *t_parse_result);
+    int ret = snowcrash::parse(source, option, result);
 
-    *report = AS_TYPE(sc_report_t, t_report);
-    *blueprint = AS_TYPE(sc_blueprint_t, t_blueprint);
-    *sm_blueprint = AS_TYPE(sc_sm_blueprint_t, t_sm_blueprint);
+    *report = AS_TYPE(sc_report_t, resultReport);
+    *blueprint = AS_TYPE(sc_blueprint_t, resultblueprint);
+    *sm_blueprint = AS_TYPE(sc_sm_blueprint_t, resultSourceMap);
 
     return ret;
 }

data/ext/snowcrash/src/snowcrash.cc

@@ -13,7 +13,7 @@ const int snowcrash::SourceAnnotation::OK = 0;
 
 using namespace snowcrash;
 
-/** 
+/**
  *  \brief  Check source for unsupported character \t & \r
  *  \return True if passed (not found), false otherwise
  */
@@ -23,7 +23,7 @@ static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
     std::string::size_type pos = source.find("\t");
 
     if (pos != std::string::npos) {
-        
+
         mdp::BytesRangeSet rangeSet;
         rangeSet.push_back(mdp::BytesRange(pos, 1));
         report.error = Error("the use of tab(s) '\\t' in source data isn't currently supported, please contact makers",
@@ -31,7 +31,7 @@ static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
                              mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
         return false;
     }
-    
+
     pos = source.find("\r");
 
     if (pos != std::string::npos) {
@@ -43,20 +43,20 @@ static bool CheckSource(const mdp::ByteBuffer& source, Report& report)
                              mdp::BytesRangeSetToCharactersRangeSet(rangeSet, source));
         return false;
     }
-    
+
     return true;
 }
 
 int snowcrash::parse(const mdp::ByteBuffer& source,
                      BlueprintParserOptions options,
-                     ParseResult<Blueprint>& out)
+                     const ParseResultRef<Blueprint>& out)
 {
     try {
-        
+
         // Sanity Check
         if (!CheckSource(source, out.report))
             return out.report.error.code;
-        
+
         // Do nothing if blueprint is empty
         if (source.empty())
             return out.report.error.code;
@@ -73,13 +73,13 @@ int snowcrash::parse(const mdp::ByteBuffer& source,
         BlueprintParser::parse(markdownAST.children().begin(), markdownAST.children(), pd, out);
     }
     catch (const std::exception& e) {
-        
+
         std::stringstream ss;
         ss << "parser exception: '" << e.what() << "'";
         out.report.error = Error(ss.str(), 1);
     }
     catch (...) {
-        
+
         out.report.error = Error("parser exception has occured", 1);
     }
 

data/ext/snowcrash/src/snowcrash.h

@@ -22,25 +22,23 @@
  *  For Snow Crash users, this is the only interface to use.
  *
  *  For binding writers, this is the point to start wrapping.
- *  Refer to https://github.com/apiaryio/snowcrash/wiki/Writing-a-binding 
+ *  Refer to https://github.com/apiaryio/snowcrash/wiki/Writing-a-binding
  *  for details on how to write a Snow Crash binding.
  */
 
 namespace snowcrash {
-    
+
     /**
      *  \brief Parse the source data into a blueprint abstract source tree (AST).
      *
-     *  \param source        A textual source data to be parsed.
-     *  \param options       Parser options. Use 0 for no additional options.
-     *  \param report        Parsing report.
-     *  \param blueprint     Parsed blueprint AST.
-     *  \param blueprintSM   Blueprint sourcemap AST
+     *  \param source       A textual source data to be parsed.
+     *  \param options      Parser options. Use 0 for no additional options.
+     *  \param out          Output buffer to store parsing result into.
      *  \return Error status code. Zero represents success, non-zero a failure.
      */
     int parse(const mdp::ByteBuffer& source,
               BlueprintParserOptions options,
-              ParseResult<Blueprint>& out);
+              const ParseResultRef<Blueprint>& out);
 }
 
 #endif