├── middle_test.tpl
├── inc_test.tpl
├── cmake
    ├── ReplicatePythonSourceTree.cmake
    ├── FindCython.cmake
    └── UseCython.cmake
├── libRedZone
    ├── src
    │   ├── IO
    │   │   ├── Reader.cpp
    │   │   ├── Writer.cpp
    │   │   ├── Writer.h
    │   │   ├── Reader.h
    │   │   ├── StringWriter.h
    │   │   ├── StringWriter.cpp
    │   │   ├── FileWriter.h
    │   │   ├── StringReader.h
    │   │   ├── StringReader.cpp
    │   │   ├── FileReader.h
    │   │   ├── FileWriter.cpp
    │   │   └── FileReader.cpp
    │   ├── Exception
    │   │   ├── JsonError.cpp
    │   │   ├── IOError.cpp
    │   │   ├── IOError.h
    │   │   ├── TemplateContextError.h
    │   │   ├── TemplateSyntaxError.h
    │   │   ├── Exception.cpp
    │   │   ├── ExpressionException.cpp
    │   │   ├── TemplateContextError.cpp
    │   │   ├── TemplateSyntaxError.cpp
    │   │   ├── ExpressionException.h
    │   │   ├── Exception.h
    │   │   └── JsonError.h
    │   ├── Template
    │   │   ├── FileTemplate.h
    │   │   ├── FileTemplate.cpp
    │   │   ├── Template.h
    │   │   └── Template.cpp
    │   ├── Node
    │   │   ├── ElseNode.h
    │   │   ├── Root.cpp
    │   │   ├── ElseNode.cpp
    │   │   ├── TextNode.h
    │   │   ├── Root.h
    │   │   ├── Variable.h
    │   │   ├── IncludeNode.h
    │   │   ├── BlockNode.h
    │   │   ├── TextNode.cpp
    │   │   ├── EachNode.h
    │   │   ├── ExtendsNode.h
    │   │   ├── IfNode.h
    │   │   ├── CacheNode.h
    │   │   ├── BlockNode.cpp
    │   │   ├── Variable.cpp
    │   │   ├── Node.cpp
    │   │   ├── IfNode.cpp
    │   │   ├── Node.h
    │   │   ├── EachNode.cpp
    │   │   ├── IncludeNode.cpp
    │   │   ├── ExtendsNode.cpp
    │   │   └── CacheNode.cpp
    │   ├── Export.h
    │   ├── Parser
    │   │   ├── Fragment.h
    │   │   ├── ExpressionParser.h
    │   │   ├── Parser.h
    │   │   ├── Fragment.cpp
    │   │   ├── Parser.cpp
    │   │   └── ExpressionParser.cpp
    │   ├── Context
    │   │   ├── Context.h
    │   │   ├── json11.hpp
    │   │   ├── Context.cpp
    │   │   └── json11.cpp
    │   ├── Common.h
    │   └── Common.cpp
    └── CMakeLists.txt
├── .gitignore
├── test.json
├── base_test.tpl
├── cython
    ├── test.py
    └── RedZone.pyx
├── main.cpp
├── LICENSE
├── test.tpl
├── CMakeLists.txt
└── README.md


/middle_test.tpl:
--------------------------------------------------------------------------------
1 | {% extends base_test.tpl %}
2 | {% block footer %}
3 |     Footer text 2
4 | {% endblock %}
5 | {% endextends %}
6 | 


--------------------------------------------------------------------------------
/inc_test.tpl:
--------------------------------------------------------------------------------
1 | {# Include successful #}
2 | {{ get( numbers, "first" ) }} should be 5
3 | {{ get( numbers, "second" ) }} should be 11
4 | {{ get( numbers, "third" ) }} should be true
5 | 


--------------------------------------------------------------------------------
/cmake/ReplicatePythonSourceTree.cmake:
--------------------------------------------------------------------------------
1 | # Note: when executed in the build dir, then CMAKE_CURRENT_SOURCE_DIR is the
2 | # build dir.
3 | file( COPY setup.py src test bin DESTINATION "${CMAKE_ARGV3}"
4 |   FILES_MATCHING PATTERN "*.py" )


--------------------------------------------------------------------------------
/libRedZone/src/IO/Reader.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Reader.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "Reader.h"
 7 | 
 8 | namespace RedZone {
 9 | 
10 | Reader::Reader() {
11 | }
12 | 
13 | Reader::~Reader() {
14 | }
15 | 
16 | } /* namespace RedZone */
17 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/Writer.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Writer.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "Writer.h"
 7 | 
 8 | namespace RedZone {
 9 | 
10 | Writer::Writer() {
11 | }
12 | 
13 | Writer::~Writer() {
14 | }
15 | 
16 | } /* namespace RedZone */
17 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/JsonError.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * JsonError.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #include "JsonError.h"
 8 | 
 9 | namespace RedZone {
10 | 
11 | JsonError::~JsonError() {
12 |     
13 | }
14 | 
15 | } /* namespace RedZone */
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Compiled Dynamic libraries
 8 | *.so
 9 | *.dylib
10 | *.dll
11 | 
12 | # Compiled Static libraries
13 | *.lai
14 | *.la
15 | *.a
16 | *.lib
17 | 
18 | # Executables
19 | *.exe
20 | *.out
21 | *.app
22 | 
23 | build
24 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/IOError.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IOError.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "IOError.h"
 9 | 
10 | namespace RedZone {
11 | 
12 | IOError::IOError( std::string const & message )
13 |     : Exception( message ) {
14 | 
15 | }
16 | 
17 | IOError::~IOError() {
18 | }
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/test.json:
--------------------------------------------------------------------------------
 1 | {                                               
 2 |    "items": [                                   
 3 |       { "text": "Hello World!", "active": true },
 4 |       { "text": "Foo", "active": true },         
 5 |       { "text": "Bar", "active": false }         
 6 |    ],
 7 |    "numbers": {
 8 |       "first": 5,
 9 |       "second": 11,
10 |       "third": true
11 |    }
12 | }
13 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/IOError.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IOError.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Exception.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class RZ_API IOError: public RedZone::Exception {
15 | public:
16 |     IOError( std::string const & message );
17 |     virtual ~IOError();
18 | };
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/Writer.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Writer.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | 
11 | #include <Export.h>
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API Writer {
16 | public:
17 |    virtual void write( std::string const & data ) = 0;
18 |    virtual void flush() = 0;
19 | 
20 |    virtual ~Writer();
21 | 
22 | protected:
23 |    Writer();
24 | };
25 | 
26 | } /* namespace RedZone */
27 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/TemplateContextError.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TemplateContextError.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Exception.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class RZ_API TemplateContextError: public Exception {
15 | public:
16 |     TemplateContextError( std::string const & contextVar );
17 |     virtual ~TemplateContextError();
18 | };
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/TemplateSyntaxError.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TemplateSyntaxError.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Exception.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class RZ_API TemplateSyntaxError: public Exception {
15 | public:
16 |     TemplateSyntaxError( std::string const & wrongSyntax );
17 |     virtual ~TemplateSyntaxError();
18 | };
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/base_test.tpl:
--------------------------------------------------------------------------------
 1 | Base tempalte text!
 2 | {% block header %}
 3 |     {% if true %}
 4 |         Header text
 5 |     {% endif %}
 6 | {% endblock %}
 7 | 
 8 | {% block mainContent %}
 9 | This text should not be in output,
10 | if this block is overloaded
11 | {% endblock %}
12 | 
13 | {% block additionalContent %}
14 | This text should be here if this block is not overloaded.
15 | {% endblock %}
16 | 
17 | {% block footer %}
18 |     Footer text
19 | {% endblock %}
20 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/Exception.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Exception.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "Exception.h"
 9 | 
10 | namespace RedZone {
11 | 
12 | Exception::Exception( std::string const & message )
13 |     : m_message( message ) {
14 | 
15 | }
16 | 
17 | const char * Exception::what() const throw() {
18 |     return m_message.c_str();
19 | }
20 | 
21 | Exception::~Exception() {
22 | }
23 | 
24 | } /* namespace RedZone */
25 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/ExpressionException.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ExpressionException.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "ExpressionException.h"
 7 | 
 8 | namespace RedZone
 9 | {
10 | 
11 | ExpressionException::ExpressionException( std::string const & expr, std::string const & err )
12 |    : Exception( "In expression \"" + expr + "\": " + err )
13 | {
14 | }
15 | 
16 | ExpressionException::~ExpressionException()
17 | {
18 | }
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/TemplateContextError.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TemplateContextError.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "TemplateContextError.h"
 9 | 
10 | namespace RedZone {
11 | 
12 | TemplateContextError::TemplateContextError( std::string const & contextVar )
13 |     : Exception( "Cannot resolve '" + contextVar + "'" ) {
14 | }
15 | 
16 | TemplateContextError::~TemplateContextError() {
17 | }
18 | 
19 | } /* namespace RedZone */
20 | 


--------------------------------------------------------------------------------
/libRedZone/src/Template/FileTemplate.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileTemplate.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include "Template.h"
10 | 
11 | #include <string>
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API FileTemplate: public Template {
16 | public:
17 | 	FileTemplate( std::string const & filePath );
18 | 	virtual ~FileTemplate();
19 | 
20 | private:
21 | 	std::string m_filePath;
22 | };
23 | 
24 | } /* namespace RedZone */
25 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/TemplateSyntaxError.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TemplateSyntaxError.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "TemplateSyntaxError.h"
 9 | 
10 | namespace RedZone {
11 | 
12 | TemplateSyntaxError::TemplateSyntaxError( std::string const & wrongSyntax )
13 |     : Exception( "'" + wrongSyntax + "' seems like invalid syntax." ) {
14 | 
15 | }
16 | 
17 | TemplateSyntaxError::~TemplateSyntaxError() {
18 | }
19 | 
20 | } /* namespace RedZone */
21 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/ExpressionException.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ExpressionException.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include "Exception.h"
10 | 
11 | namespace RedZone
12 | {
13 | 
14 | class RZ_API ExpressionException : public Exception
15 | {
16 | public:
17 |    using Exception::Exception;
18 | 
19 |    ExpressionException( std::string const & expr, std::string const & err );
20 | 
21 |    virtual ~ExpressionException();
22 | };
23 | 
24 | } /* namespace RedZone */
25 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/Reader.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Reader.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | 
11 | #include <Export.h>
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API Reader {
16 | public:
17 |    virtual std::string read( size_t nBytes ) = 0;
18 |    virtual std::string readAll() = 0;
19 |    virtual std::string id() const = 0;
20 | 
21 |    virtual ~Reader();
22 | 
23 | protected:
24 |    Reader();
25 | };
26 | 
27 | } /* namespace RedZone */
28 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/ElseNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ElseNode.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Node.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class Writer;
15 | 
16 | class RZ_API ElseNode: public Node {
17 | public:
18 |     ElseNode();
19 | 
20 |     virtual void render( Writer * stream, Context * context ) const;
21 | 
22 |     virtual std::string name() const;
23 | 
24 |     virtual ~ElseNode();
25 | };
26 | 
27 | } /* namespace RedZone */
28 | 


--------------------------------------------------------------------------------
/cython/test.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #-*- coding: utf-8 -*-
 3 | __author__ = 'jc'
 4 | 
 5 | from RedZone import *
 6 | 
 7 | context = Context({
 8 |     "items": [
 9 |         {"text": "Hello World!", "active": True},
10 |         {"text": "Foo", "active": True},
11 |         {"text": "Bar", "active": False}
12 |     ],
13 |     "numbers": {
14 |         "first": 5,
15 |         "second": 11,
16 |         "third": True
17 |     }
18 | })
19 | tpl = FileTemplate('test.tpl')
20 | 
21 | print tpl.render(context)
22 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/Root.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Root.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "Root.h"
 9 | 
10 | namespace RedZone {
11 | 
12 | Root::Root( std::string id )
13 |     : Node(), m_id( id ) {
14 | 
15 | }
16 | 
17 | void Root::render( Writer * stream, Context * context ) const {
18 |     renderChildren( stream, context );
19 | }
20 | 
21 | std::string Root::name() const {
22 |    return "Root";
23 | }
24 | 
25 | Root::~Root() {
26 | }
27 | 
28 | } /* namespace RedZone */
29 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/StringWriter.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * StringWriter.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | 
11 | #include "Writer.h"
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API StringWriter : public Writer {
16 | public:
17 |    StringWriter( std::string & string );
18 | 
19 |    virtual void write( std::string const & data );
20 |    virtual void flush();
21 | 
22 |    virtual ~StringWriter();
23 | 
24 | protected:
25 |    std::string & m_string;
26 | };
27 | 
28 | } /* namespace RedZone */
29 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/ElseNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ElseNode.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "ElseNode.h"
 9 | 
10 | #include <Context/Context.h>
11 | #include <Parser/Fragment.h>
12 | 
13 | namespace RedZone {
14 | 
15 | ElseNode::ElseNode()
16 |     : Node() {
17 | 
18 | }
19 | 
20 | void ElseNode::render( Writer *, Context * ) const {
21 | 
22 | }
23 | 
24 | std::string ElseNode::name() const {
25 |    return "Else";
26 | }
27 | 
28 | ElseNode::~ElseNode() {
29 | }
30 | 
31 | } /* namespace RedZone */
32 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/Exception.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Exception.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <stdexcept>
10 | #include <string>
11 | 
12 | #include <Export.h>
13 | 
14 | namespace RedZone {
15 | 
16 | class RZ_API Exception: public std::exception {
17 | public:
18 |     Exception( std::string const & message );
19 |     virtual ~Exception();
20 | 
21 |     virtual const char * what() const throw();
22 | 
23 | protected:
24 |     std::string m_message;
25 | };
26 | 
27 | } /* namespace RedZone */
28 | 


--------------------------------------------------------------------------------
/libRedZone/src/Template/FileTemplate.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileTemplate.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include <fstream>
 9 | 
10 | #include <Exception/IOError.h>
11 | #include <IO/FileReader.h>
12 | 
13 | #include "FileTemplate.h"
14 | 
15 | namespace RedZone {
16 | 
17 | FileTemplate::FileTemplate( std::string const & filePath )
18 | 	: m_filePath( filePath ) {
19 |    FileReader in( filePath );
20 |    loadFromStream( &in );
21 | }
22 | 
23 | FileTemplate::~FileTemplate() {
24 | }
25 | 
26 | } /* namespace RedZone */
27 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/StringWriter.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * StringWriter.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "StringWriter.h"
 7 | 
 8 | #include <iterator>
 9 | 
10 | namespace RedZone {
11 | 
12 | StringWriter::StringWriter( std::string & string )
13 |    : m_string( string ) {
14 | }
15 | 
16 | void StringWriter::write( std::string const & data ) {
17 |    std::copy( data.begin(), data.end(), std::back_inserter( m_string ) );
18 | }
19 | 
20 | void StringWriter::flush() {
21 | 
22 | }
23 | 
24 | StringWriter::~StringWriter() {
25 | }
26 | 
27 | } /* namespace RedZone */
28 | 


--------------------------------------------------------------------------------
/libRedZone/src/Export.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Export.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #if defined( RZ_STATIC )
10 | #   define RZ_API
11 | #elif defined( __GNUC__ ) && __GNUC__ >= 4 && defined( RZ_EXPORTS )
12 | #   define RZ_API __attribute__ ( ( visibility( "default" ) ) )
13 | #elif defined( _MSC_VER )
14 | #   if defined( RZ_EXPORTS )
15 | #		define RZ_API __declspec( dllexport )
16 | #   else
17 | #       define RZ_API __declspec( dllimport )
18 | #   endif defined( RZ_EXPORTS )
19 | #else
20 |    #define RZ_API
21 | #endif // defined( RZ_STATIC )
22 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/FileWriter.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileWriter.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <fstream>
10 | 
11 | #include "Writer.h"
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API FileWriter : public Writer {
16 | public:
17 |    FileWriter( std::string const & fileName );
18 | 
19 |    virtual void write( std::string const & data );
20 |    virtual void flush();
21 | 
22 |    virtual ~FileWriter();
23 | 
24 | protected:
25 |    std::ofstream m_file;
26 | 
27 | private:
28 |    FileWriter( FileWriter const & ) { }
29 | };
30 | 
31 | } /* namespace RedZone */
32 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/TextNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TextNode.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Node.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class Writer;
15 | 
16 | class RZ_API TextNode: public Node {
17 | public:
18 |     TextNode();
19 | 
20 |     virtual void render( Writer * stream, Context * context ) const;
21 |     virtual void processFragment( Fragment const * fragment );
22 | 
23 |     virtual std::string name() const;
24 | 
25 |     virtual ~TextNode();
26 | 
27 | protected:
28 |     std::string m_text;
29 | };
30 | 
31 | } /* namespace RedZone */
32 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/Root.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Root.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include <string>
11 | 
12 | #include "Node.h"
13 | 
14 | namespace RedZone {
15 | 
16 | class Writer;
17 | 
18 | class RZ_API Root : public Node {
19 | public:
20 |     Root( std::string id );
21 | 
22 |     virtual void render( Writer * stream, Context * context ) const;
23 | 
24 |     virtual std::string name() const;
25 | 
26 |     inline std::string id() const { return m_id; }
27 | 
28 |     virtual ~Root();
29 | 
30 | protected:
31 |     std::string m_id;
32 | };
33 | 
34 | } /* namespace RedZone */
35 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/StringReader.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * StringReader.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | 
11 | #include "Reader.h"
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API StringReader : public Reader {
16 | public:
17 |    StringReader( std::string const & string );
18 | 
19 |    virtual std::string read( size_t nBytes );
20 |    virtual std::string readAll();
21 |    virtual std::string id() const;
22 | 
23 |    virtual ~StringReader();
24 | 
25 | protected:
26 |    std::string const & m_string;
27 |    std::string::const_iterator m_iter;
28 | };
29 | 
30 | } /* namespace RedZone */
31 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/Fragment.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Fragment.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | 
11 | #include "Parser.h"
12 | 
13 | namespace RedZone {
14 | 
15 | class RZ_API Fragment {
16 | public:
17 |     Fragment( std::string const & rawText );
18 | 
19 |     std::string cleanFragment() const;
20 | 
21 |     ElementType type() const;
22 | 
23 |     std::string raw() const;
24 |     std::string clean() const;
25 | 
26 |     virtual ~Fragment();
27 | 
28 | protected:
29 |     std::string m_rawText;
30 |     std::string m_cleanText;
31 | };
32 | 
33 | } /* namespace RedZone */
34 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/Variable.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Variable.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <Export.h>
10 | 
11 | #include "Node.h"
12 | 
13 | namespace RedZone {
14 | 
15 | class Fragment;
16 | 
17 | class RZ_API Variable: public Node {
18 | public:
19 |     Variable();
20 | 
21 |     virtual void render( Writer * stream, Context * context ) const;
22 | 
23 |     virtual void processFragment( Fragment const * fragment );
24 | 
25 |     virtual std::string name() const;
26 | 
27 |     virtual ~Variable();
28 | 
29 | protected:
30 |     std::string m_expression;
31 | };
32 | 
33 | } /* namespace RedZone */
34 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/IncludeNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IncludeNode.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <string>
10 | #include <vector>
11 | 
12 | #include "Node.h"
13 | 
14 | namespace RedZone {
15 | 
16 | class Root;
17 | 
18 | class RZ_API IncludeNode : public Node {
19 | public:
20 |    IncludeNode();
21 | 
22 |    virtual void render( Writer * stream, Context * context ) const;
23 | 
24 |    virtual void processFragment( Fragment const * fragment );
25 | 
26 |    virtual std::string name() const;
27 | 
28 |    virtual ~IncludeNode();
29 | 
30 | protected:
31 |    std::string m_includeExpr;
32 | };
33 | 
34 | } /* namespace RedZone */
35 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/BlockNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BlockNode.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include "Node.h"
10 | 
11 | namespace RedZone {
12 | 
13 | class RZ_API BlockNode : public Node {
14 | public:
15 |    BlockNode();
16 | 
17 |    virtual void render( Writer * stream, Context * context ) const;
18 |    virtual void processFragment( Fragment const * fragment );
19 |    virtual void exitScope( std::string const & endTag );
20 | 
21 |    virtual std::string name() const;
22 |    std::string blockName() const;
23 | 
24 |    virtual ~BlockNode();
25 | 
26 | protected:
27 |    std::string m_blockName;
28 | };
29 | 
30 | } /* namespace RedZone */
31 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/StringReader.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * StringReader.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "StringReader.h"
 7 | 
 8 | namespace RedZone {
 9 | 
10 | StringReader::StringReader( std::string const & string )
11 |    : m_string( string ), m_iter( m_string.begin() ) {
12 | }
13 | 
14 | std::string StringReader::read( size_t nBytes ) {
15 |    std::string result( m_iter, m_iter + nBytes );
16 |    m_iter += nBytes;
17 |    return result;
18 | }
19 | 
20 | std::string StringReader::readAll() {
21 |    return m_string;
22 | }
23 | 
24 | std::string StringReader::id() const {
25 |     return "<string>";
26 | }
27 | 
28 | StringReader::~StringReader() {
29 | }
30 | 
31 | } /* namespace RedZone */
32 | 


--------------------------------------------------------------------------------
/libRedZone/src/Exception/JsonError.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * JsonError.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Exception.h"
11 | 
12 | #include <Common.h>
13 | 
14 | namespace RedZone {
15 | 
16 | class RZ_API JsonError: public Exception {
17 | public:
18 | #if defined( RZ_UNIX )
19 |     using Exception::Exception;
20 | #elif defined( RZ_WINDOWS )
21 | #   pragma message( "Stupid M$VC compiler does not support constructor inheritance!" )
22 | 	JsonError( std::string const & message ) : Exception( message ) 
23 | 	{
24 | 	}
25 | #else
26 | #   error( "Not implemented yet" )
27 | #endif
28 |     virtual ~JsonError();
29 | };
30 | 
31 | } /* namespace RedZone */
32 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/TextNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * TextNode.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #include "TextNode.h"
 8 | 
 9 | #include <IO/Writer.h>
10 | #include <Parser/Fragment.h>
11 | 
12 | namespace RedZone {
13 | 
14 | TextNode::TextNode()
15 |     : Node() {
16 | 
17 | }
18 | 
19 | void TextNode::render( Writer * stream, Context * context ) const {
20 |     (void)context;
21 |     stream->write( m_text );
22 | }
23 | 
24 | void TextNode::processFragment( Fragment const * fragment ) {
25 |     m_text = fragment->raw();
26 | }
27 | 
28 | std::string TextNode::name() const {
29 |    return "Text";
30 | }
31 | 
32 | TextNode::~TextNode() {
33 | }
34 | 
35 | } /* namespace RedZone */
36 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/FileReader.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileReader.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <fstream>
10 | #include <iterator>
11 | #include <string>
12 | 
13 | #include "Reader.h"
14 | 
15 | namespace RedZone {
16 | 
17 | class RZ_API FileReader : public Reader {
18 | public:
19 |    FileReader( std::string const & fileName );
20 | 
21 |    virtual std::string read( size_t nBytes );
22 |    virtual std::string readAll();
23 |    virtual std::string id() const;
24 | 
25 |    virtual ~FileReader();
26 | 
27 | protected:
28 |    std::ifstream m_file;
29 |    std::string m_path;
30 | 
31 | private:
32 |    FileReader( FileReader const & ) { }
33 | };
34 | 
35 | } /* namespace RedZone */
36 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/EachNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * EachNode.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include "Node.h"
11 | 
12 | namespace RedZone {
13 | 
14 | class Writer;
15 | 
16 | class RZ_API EachNode: public Node {
17 | public:
18 |     EachNode();
19 | 
20 |     virtual void render( Writer * stream, Context * context ) const;
21 |     virtual void processFragment( Fragment const * fragment );
22 |     virtual void exitScope( std::string const & endTag );
23 |     virtual std::string name() const;
24 | 
25 |     virtual ~EachNode();
26 | 
27 | protected:
28 |     std::string m_container;
29 |     std::vector< std::string > m_vars;
30 | };
31 | 
32 | } /* namespace RedZone */
33 | 


--------------------------------------------------------------------------------
/libRedZone/src/Template/Template.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Template.h
 3 |  *
 4 |  *  Created on: 21 ���� 2014 �.
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <memory>
10 | #include <string>
11 | #include <vector>
12 | 
13 | #include <Export.h>
14 | 
15 | namespace RedZone {
16 | 
17 | class Context;
18 | class Reader;
19 | class Root;
20 | class Writer;
21 | 
22 | class RZ_API Template {
23 | public:
24 | 	virtual ~Template();
25 | 
26 | 	void renderToStream( Writer * stream, Context * context ) const;
27 | 	std::string render( Context * context ) const;
28 | 
29 | protected:
30 | 	Template();
31 | 	void loadFromStream( Reader * stream );
32 | 
33 | protected:
34 | 	std::shared_ptr< Root const > m_root;
35 | };
36 | 
37 | } /* namespace RedZone */
38 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/FileWriter.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileWriter.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "FileWriter.h"
 7 | 
 8 | #include <algorithm>
 9 | #include <iterator>
10 | 
11 | #include <Exception/IOError.h>
12 | 
13 | namespace RedZone {
14 | 
15 | FileWriter::FileWriter( std::string const & fileName )
16 |    : m_file( fileName ) {
17 |    if( !m_file.good() ) {
18 |       throw IOError( "Can not create " + fileName + " file." );
19 |    }
20 | }
21 | 
22 | void FileWriter::write( std::string const & data ) {
23 |    std::copy( data.begin(), data.end(), std::ostream_iterator< char >( m_file ) );
24 | }
25 | 
26 | void FileWriter::flush() {
27 |    m_file.flush();
28 | }
29 | 
30 | FileWriter::~FileWriter() {
31 | }
32 | 
33 | } /* namespace RedZone */
34 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/ExtendsNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ExtendsNode.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include "Node.h"
10 | 
11 | namespace RedZone {
12 | 
13 | class Root;
14 | 
15 | class RZ_API ExtendsNode : public Node {
16 | public:
17 |    ExtendsNode();
18 | 
19 |    virtual void render( Writer * stream, Context * context ) const;
20 |    virtual void processFragment( Fragment const * fragment );
21 |    virtual void exitScope( std::string const & endTag );
22 | 
23 |    virtual std::string name() const;
24 | 
25 |    virtual ~ExtendsNode();
26 | 
27 | protected:
28 |    std::string m_path;
29 |    std::vector< std::shared_ptr< Node > > m_nodesToRender;
30 |    std::shared_ptr< Root > m_parentRoot;
31 | };
32 | 
33 | } /* namespace RedZone */
34 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/ExpressionParser.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ExpressionParser.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | 
 7 | #pragma once
 8 | 
 9 | #include <functional>
10 | #include <set>
11 | #include <string>
12 | 
13 | #include <Context/json11.hpp>
14 | #include <Export.h>
15 | 
16 | namespace RedZone
17 | {
18 | 
19 | class Context;
20 | 
21 | class RZ_API ExpressionParser
22 | {
23 | public:
24 |    typedef std::set< char > charset;
25 | 
26 |    ExpressionParser( Context const * context );
27 | 
28 |    json11::Json parse( std::string expression ) const;
29 | 
30 |    virtual ~ExpressionParser();
31 | 
32 | protected:
33 |    json11::Json parseRecursive( std::string expression ) const;
34 | 
35 | protected:
36 |    Context const * m_context;
37 |    charset m_binaryOperatorChars;
38 | };
39 | 
40 | } /* namespace RedZone */
41 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/IfNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IfNode.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include <Context/json11.hpp>
11 | 
12 | #include "Node.h"
13 | 
14 | namespace RedZone {
15 | 
16 | class Writer;
17 | 
18 | class RZ_API IfNode: public Node {
19 | public:
20 | 
21 |     IfNode();
22 | 
23 |     virtual void render( Writer * stream, Context * context ) const;
24 | 
25 |     virtual void processFragment( Fragment const * fragment );
26 |     virtual void exitScope( std::string const & endTag );
27 | 
28 |     virtual std::string name() const;
29 | 
30 |     virtual ~IfNode();
31 | 
32 | protected:
33 |     std::string m_expression;
34 |     std::vector< std::shared_ptr< Node > > m_ifNodes;
35 |     std::vector< std::shared_ptr< Node > > m_elseNodes;
36 | };
37 | 
38 | } /* namespace RedZone */
39 | 


--------------------------------------------------------------------------------
/libRedZone/src/IO/FileReader.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * FileReader.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "FileReader.h"
 7 | 
 8 | #include <Exception/IOError.h>
 9 | 
10 | namespace RedZone {
11 | 
12 | FileReader::FileReader( std::string const & fileName )
13 |    : m_file( fileName ), m_path( fileName ) {
14 |    if( !m_file.good() ) {
15 |       throw IOError( "Can not open " + fileName + " file." );
16 |    }
17 | }
18 | 
19 | std::string FileReader::read( size_t nBytes ) {
20 |    std::string result( nBytes, '\0' );
21 |    m_file.read( &result[ 0 ], nBytes );
22 |    return result;
23 | }
24 | 
25 | std::string FileReader::readAll() {
26 |    return std::string( std::istreambuf_iterator< char >( m_file ), std::istreambuf_iterator< char >() );
27 | }
28 | 
29 | std::string FileReader::id() const {
30 |     return m_path;
31 | }
32 | 
33 | FileReader::~FileReader() {
34 | }
35 | 
36 | } /* namespace RedZone */
37 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/CacheNode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * CacheNode.h
 3 |  *
 4 |  *  Created on: 2015
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include "Node.h"
10 | 
11 | #include <chrono>
12 | #include <unordered_map>
13 | 
14 | namespace RedZone {
15 | 
16 | class RZ_API CacheNode: public Node {
17 | public:
18 |     CacheNode();
19 | 
20 |     virtual void render( Writer * stream, Context * context ) const;
21 |     virtual void processFragment( Fragment const * fragment );
22 |     virtual void exitScope( std::string const & endTag );
23 |     virtual std::string name() const;
24 | 
25 |     virtual ~CacheNode();
26 | 
27 |     typedef std::tuple< std::chrono::time_point< 
28 |        std::chrono::system_clock>, std::string > CacheRow;
29 | 
30 | protected:
31 |     uint64_t m_cacheTime;
32 |     std::vector< std::string > m_vars;
33 |     static std::unordered_map< size_t, CacheRow > s_cached;
34 | };
35 | 
36 | } /* namespace RedZone */
37 | 


--------------------------------------------------------------------------------
/libRedZone/src/Template/Template.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Template.cpp
 3 |  *
 4 |  *  Created on: 21 ���� 2014 �.
 5 |  *      Author: jc
 6 |  */
 7 | #include <algorithm>
 8 | #include <functional>
 9 | 
10 | #include <IO/StringWriter.h>
11 | #include <Node/Root.h>
12 | #include <Parser/Parser.h>
13 | 
14 | #include "Template.h"
15 | 
16 | using namespace std::placeholders;
17 | 
18 | namespace RedZone {
19 | 
20 | Template::Template() {
21 | }
22 | 
23 | void Template::renderToStream( Writer * stream, Context * context ) const {
24 |    m_root->render( stream, context );
25 | }
26 | 
27 | std::string Template::render( Context * context ) const {
28 |    std::string result;
29 |    StringWriter stringWriter( result );
30 |    renderToStream( &stringWriter, context );
31 |    return result;
32 | }
33 | 
34 | void Template::loadFromStream( Reader * stream ) {
35 |    Parser parser;
36 |    m_root.reset( parser.loadFromStream( stream ) );
37 | }
38 | 
39 | Template::~Template() {
40 | }
41 | 
42 | } /* namespace RedZone */
43 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * main.cpp
 3 |  *
 4 |  *  Created on: 2014.
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include <Context/Context.h>
 9 | #include <Exception/Exception.h>
10 | #include <Template/FileTemplate.h>
11 | 
12 | #include <fstream>
13 | #include <iostream>
14 | #include <string>
15 | 
16 | using namespace json11;
17 | 
18 | int main( int argc, char ** argv )
19 | {
20 |     RedZone::FileTemplate tpl( "test.tpl" );
21 | 
22 |     std::ifstream jsonIn( "test.json" );
23 |     if( !jsonIn.good() ) {
24 |        return 1;
25 |     }
26 | 
27 |     std::string err;
28 | 
29 |     Json json( Json::parse(
30 |        std::string(
31 |           std::istreambuf_iterator< char >( jsonIn ),
32 |           std::istreambuf_iterator< char >() ),
33 |           err ) );
34 | 
35 |     if( err.length() ) {
36 |        std::cerr << err << std::endl;
37 |        return 1;
38 |     }
39 | 
40 |     RedZone::Context * cont( new RedZone::Context( json ) );
41 | 
42 |     try {
43 |       std::cout << tpl.render( cont ) << std::endl;
44 |     }
45 |     catch( RedZone::Exception const & exception ) {
46 |       std::cerr << exception.what() << std::endl;
47 |     }
48 | 
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/BlockNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BlockNode.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "BlockNode.h"
 7 | 
 8 | #include <regex>
 9 | 
10 | #include <Exception/TemplateSyntaxError.h>
11 | #include <Parser/Fragment.h>
12 | 
13 | namespace RedZone {
14 | 
15 | BlockNode::BlockNode()
16 |    : Node( true ) {
17 | }
18 | 
19 | void BlockNode::render( Writer * stream, Context * context ) const {
20 |    renderChildren( stream, context );
21 | }
22 | 
23 | void BlockNode::processFragment( Fragment const * fragment ) {
24 |    static std::regex const blockSplitter( R"(^block\s+(\w+)$)" );
25 |    std::smatch match;
26 |    std::string cleaned = fragment->clean();
27 |    if( ! std::regex_match( cleaned, match, blockSplitter ) ) {
28 |       throw TemplateSyntaxError( fragment->clean() );
29 |    }
30 |    m_blockName = match[ 1 ];
31 | }
32 | 
33 | void BlockNode::exitScope( std::string const & endTag ) {
34 |    if( endTag != "endblock" )
35 |       throw TemplateSyntaxError( endTag );
36 | }
37 | 
38 | std::string BlockNode::name() const {
39 |    return "Block";
40 | }
41 | 
42 | std::string BlockNode::blockName() const {
43 |    return m_blockName;
44 | }
45 | 
46 | BlockNode::~BlockNode() {
47 | }
48 | 
49 | } /* namespace RedZone */
50 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/Parser.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Parser.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #pragma once
 9 | 
10 | #include <functional>
11 | #include <map>
12 | #include <vector>
13 | 
14 | #include <Export.h>
15 | 
16 | #define BLOCK_START_TOKEN   "{%"
17 | #define BLOCK_END_TOKEN     "%}"
18 | #define VAR_START_TOKEN     "{{"
19 | #define VAR_END_TOKEN       "}}"
20 | #define COMMENT_START_TOKEN "{#"
21 | #define COMMENT_END_TOKEN   "#}"
22 | 
23 | namespace RedZone {
24 | 
25 | class Fragment;
26 | class Node;
27 | class Reader;
28 | class Root;
29 | 
30 | enum class ElementType {
31 |     VarElement,
32 |     OpenBlockFragment,
33 |     CloseBlockFragment,
34 |     TextFragment
35 | };
36 | 
37 | class RZ_API Parser {
38 | public:
39 |     Parser();
40 | 
41 |     Root * loadFromStream( Reader * stream ) const;
42 | 
43 |     static void addPath( std::string path );
44 |     static std::vector< std::string > const & paths();
45 | 
46 |     virtual ~Parser();
47 | 
48 | protected:
49 |     Node * createNode( Fragment const * fragment ) const;
50 | 
51 | protected:
52 |     static const std::map<
53 |         std::string, std::function< Node * () >
54 |         > s_nodeCreators;
55 | 
56 |     static std::vector< std::string > s_paths;
57 | };
58 | 
59 | } /* namespace RedZone */
60 | 


--------------------------------------------------------------------------------
/libRedZone/src/Context/Context.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Context.h
 3 |  *
 4 |  *  Created on: 21 ���� 2014 �.
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <functional>
10 | #include <map>
11 | #include <string>
12 | #include <vector>
13 | 
14 | #include <Export.h>
15 | 
16 | #include "json11.hpp"
17 | 
18 | namespace RedZone {
19 | 
20 | class RZ_API Context {
21 | public:
22 |    typedef std::function< json11::Json( json11::Json const &, json11::Json const & ) > BinaryOperator;
23 |    typedef std::vector< std::tuple< std::string, int, BinaryOperator > > BinaryOperators;
24 | 
25 |    typedef std::function< json11::Json( std::vector< json11::Json > const & ) > Function;
26 |    typedef std::map< std::string, Function > Functions;
27 | 
28 | 	Context( std::string const & json );
29 | 
30 | 	Context( json11::Json const & json );
31 | 
32 | 	json11::Json json() const;
33 | 	void setJson( json11::Json const & json );
34 | 
35 | 	json11::Json resolve( std::string const & name ) const;
36 | 
37 | 	BinaryOperators const & binaryOperators() const;
38 | 	Functions const & functions() const;
39 | 
40 | 	virtual ~Context();
41 | 
42 | protected:
43 | 	Context();
44 | 
45 | protected:
46 | 	json11::Json m_json;
47 | 	BinaryOperators m_binaryOperations;
48 | 	Functions m_functions;
49 | };
50 | 
51 | } /* namespace RedZone */
52 | 


--------------------------------------------------------------------------------
/libRedZone/src/Common.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Common.h
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #pragma once
 7 | 
 8 | #if defined( __linux__ )
 9 | #  define RZ_LINUX
10 | #elif defined( __APPLE__ )
11 | #  define RZ_MACOS
12 | #elif defined( _WIN32 ) || defined( _WIN64 )
13 | #  define RZ_WINDOWS
14 | #else
15 | #  error "Unknown OS"
16 | #endif
17 | 
18 | #if defined( RZ_LINUX ) || defined( RZ_MACOS )
19 | #	define RZ_UNIX
20 | #endif
21 | 
22 | #include <memory>
23 | #include <string>
24 | 
25 | #include <Exception/Exception.h>
26 | 
27 | namespace RedZone {
28 | 
29 | // Taken from here http://stackoverflow.com/a/15167203/2080453
30 | std::string dbl2str( double d );
31 | 
32 | std::string replaceString( std::string subject, const std::string & search, const std::string & replace );
33 | 
34 | void trimString( std::string & str );
35 | 
36 | bool isReadableFile( std::string const & filePath );
37 | 
38 | using StrConcat = std::string( * )( std::string const &, std::string const & );
39 | static StrConcat strConcat = std::operator+;
40 | 
41 | template< class T >
42 | std::shared_ptr< T > weakToShared( std::weak_ptr< T > weakPtr )
43 | {
44 |    if( std::shared_ptr< T > sharedPtr = weakPtr.lock() )
45 |    {
46 |       return sharedPtr;
47 |    }
48 |    throw Exception( "Failed to acquire an object" );
49 | }
50 | 
51 | } /* namespace RedZone */
52 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2014, Ivan Il'in
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/Variable.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Variable.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "Variable.h"
 9 | 
10 | #include <Common.h>
11 | #include <IO/Writer.h>
12 | #include <Parser/ExpressionParser.h>
13 | #include <Parser/Fragment.h>
14 | 
15 | using namespace json11;
16 | 
17 | namespace RedZone {
18 | 
19 | Variable::Variable()
20 |    : Node() {
21 | 
22 | }
23 | 
24 | void Variable::render( Writer * stream, Context * context ) const {
25 |    ExpressionParser parser( context );
26 |    Json result = parser.parse( m_expression );
27 |    switch( result.type() ) {
28 |       case Json::NUL:
29 |          stream->write( "null" );
30 |          break;
31 |       case Json::NUMBER:
32 |          stream->write( dbl2str( result.number_value() ) );
33 |          break;
34 |       case Json::STRING:
35 |          stream->write( result.string_value() );
36 |          break;
37 |       case Json::BOOL:
38 |          stream->write( result.bool_value() ? "true" : "false" );
39 |          break;
40 |       case Json::ARRAY:
41 |       case Json::OBJECT:
42 |          stream->write( result.dump() );
43 |          break;
44 |    }
45 | }
46 | 
47 | void Variable::processFragment( Fragment const * fragment ) {
48 |    m_expression = fragment->clean();
49 | }
50 | 
51 | std::string Variable::name() const {
52 |    return "Variable";
53 | }
54 | 
55 | Variable::~Variable() {
56 | }
57 | 
58 | } /* namespace RedZone */
59 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/Fragment.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Fragment.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "Fragment.h"
 9 | 
10 | #include <algorithm>
11 | #include <iterator>
12 | 
13 | #include <Common.h>
14 | 
15 | namespace RedZone {
16 | 
17 | Fragment::Fragment( std::string const & rawText )
18 |     : m_rawText( rawText ) {
19 |     m_cleanText = cleanFragment();
20 | }
21 | 
22 | std::string Fragment::cleanFragment() const {
23 |    static std::vector< std::string > const starts { BLOCK_START_TOKEN, VAR_START_TOKEN };
24 |    if( std::find( starts.begin(),
25 |           starts.end(), m_rawText.substr( 0, 2 ) ) != starts.end() ) {
26 |       std::string result;
27 |       std::copy( m_rawText.begin() + 2, m_rawText.end() - 2, std::back_inserter( result ) );
28 |       trimString( result );
29 |       return result;
30 |    }
31 |    return m_rawText;
32 | }
33 | 
34 | ElementType Fragment::type() const {
35 |    std::string rawStart = m_rawText.substr( 0, 2 );
36 |    if( rawStart == VAR_START_TOKEN ) {
37 |       return ElementType::VarElement;
38 |    }
39 |    else if ( rawStart == BLOCK_START_TOKEN ) {
40 |       return ( m_cleanText.find( "end" ) == 0 ?
41 |          ElementType::CloseBlockFragment : ElementType::OpenBlockFragment );
42 |    }
43 |    return ElementType::TextFragment;
44 | }
45 | 
46 | std::string Fragment::raw() const {
47 |    return m_rawText;
48 | }
49 | 
50 | std::string Fragment::clean() const {
51 |    return m_cleanText;
52 | }
53 | 
54 | Fragment::~Fragment() {
55 | }
56 | 
57 | } /* namespace RedZone */
58 | 


--------------------------------------------------------------------------------
/cmake/FindCython.cmake:
--------------------------------------------------------------------------------
 1 | # Find the Cython compiler.
 2 | #
 3 | # This code sets the following variables:
 4 | #
 5 | #  CYTHON_EXECUTABLE
 6 | #
 7 | # See also UseCython.cmake
 8 | 
 9 | #=============================================================================
10 | # Copyright 2011 Kitware, Inc.
11 | #
12 | # Licensed under the Apache License, Version 2.0 (the "License");
13 | # you may not use this file except in compliance with the License.
14 | # You may obtain a copy of the License at
15 | #
16 | #     http://www.apache.org/licenses/LICENSE-2.0
17 | #
18 | # Unless required by applicable law or agreed to in writing, software
19 | # distributed under the License is distributed on an "AS IS" BASIS,
20 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 | # See the License for the specific language governing permissions and
22 | # limitations under the License.
23 | #=============================================================================
24 | 
25 | # Use the Cython executable that lives next to the Python executable
26 | # if it is a local installation.
27 | find_package( PythonInterp )
28 | if( PYTHONINTERP_FOUND )
29 |   get_filename_component( _python_path ${PYTHON_EXECUTABLE} PATH )
30 |   find_program( CYTHON_EXECUTABLE
31 |     NAMES cython cython.bat cython3
32 |     HINTS ${_python_path}
33 |     )
34 | else()
35 |   find_program( CYTHON_EXECUTABLE
36 |     NAMES cython cython.bat cython3
37 |     )
38 | endif()
39 | 
40 | 
41 | include( FindPackageHandleStandardArgs )
42 | FIND_PACKAGE_HANDLE_STANDARD_ARGS( Cython REQUIRED_VARS CYTHON_EXECUTABLE )
43 | 
44 | mark_as_advanced( CYTHON_EXECUTABLE )


--------------------------------------------------------------------------------
/libRedZone/src/Node/Node.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Node.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "Node.h"
 9 | 
10 | #include <Context/Context.h>
11 | #include <IO/Writer.h>
12 | 
13 | using namespace std::placeholders;
14 | 
15 | namespace RedZone {
16 | 
17 | Node::Node( bool createsScope )
18 |     : m_createsScope( createsScope ) {
19 | 
20 | }
21 | 
22 | void Node::render( Writer * stream, Context * context ) const {
23 |     stream->write( "*** NOT IMPLEMENTED ***" );
24 | }
25 | 
26 | void Node::renderChildren( Writer * stream, Context * context,
27 |         std::vector< std::shared_ptr< Node > > children ) const {
28 |     if( !children.size() )
29 |         children = m_children;
30 |     std::for_each( children.begin(), children.end(),
31 |             std::bind( &Node::render, _1, stream, context ) );
32 | }
33 | 
34 | void Node::addChild( Node * child ) {
35 |     m_children.push_back( std::shared_ptr< Node >( child ) );
36 | }
37 | 
38 | bool Node::createsScope() const {
39 |     return m_createsScope;
40 | }
41 | 
42 | json11::Json Node::resolveInContext( std::string const & name, Context const * context ) const {
43 |     return context->resolve( name );
44 | }
45 | 
46 | void Node::processFragment( Fragment const * fragment ) {
47 | }
48 | 
49 | void Node::enterScope() {
50 | }
51 | 
52 | void Node::exitScope( std::string const & ) {
53 | }
54 | 
55 | std::string Node::name() const {
56 |    return "Node";
57 | }
58 | 
59 | std::vector< std::shared_ptr< Node > > const & Node::children() {
60 |    return m_children;
61 | }
62 | 
63 | Node::~Node() {
64 | 
65 | }
66 | 
67 | } /* namespace RedZone */
68 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/IfNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IfNode.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "IfNode.h"
 9 | 
10 | #include <algorithm>
11 | #include <iterator>
12 | #include <regex>
13 | #include <set>
14 | #include <typeinfo>
15 | 
16 | #include <Context/Context.h>
17 | #include <Context/json11.hpp>
18 | #include <Exception/TemplateSyntaxError.h>
19 | #include <Parser/ExpressionParser.h>
20 | #include <Parser/Fragment.h>
21 | 
22 | using namespace json11;
23 | 
24 | namespace RedZone {
25 | 
26 | IfNode::IfNode()
27 |     : Node( true ) {
28 | 
29 | }
30 | 
31 | void IfNode::render( Writer * stream, Context * context ) const {
32 |    ExpressionParser parser( context );
33 |    if( parser.parse( m_expression ).bool_value() ) {
34 |       renderChildren( stream, context, m_ifNodes );
35 |    } else {
36 |       renderChildren( stream, context, m_elseNodes );
37 |    }
38 | }
39 | 
40 | void IfNode::exitScope( std::string const & endTag ) {
41 |    if( endTag != "endif" )
42 |       throw TemplateSyntaxError( endTag );
43 |    std::vector< std::shared_ptr< Node > > * current = &m_ifNodes;
44 |    for( auto child: m_children ) {
45 |       if( child->name() == "Else" ) {
46 |          current = &m_elseNodes;
47 |          continue;
48 |       }
49 |       current->push_back( child );
50 |    }
51 | }
52 | 
53 | void IfNode::processFragment( Fragment const * fragment ) {
54 |     std::string clean = fragment->clean();
55 |     m_expression.clear();
56 |     m_ifNodes.clear();
57 |     m_elseNodes.clear();
58 |     std::copy( clean.begin() + 3, clean.end(), std::back_inserter( m_expression ) );
59 | }
60 | 
61 | std::string IfNode::name() const {
62 |    return "If";
63 | }
64 | 
65 | IfNode::~IfNode() {
66 | }
67 | 
68 | } /* namespace RedZone */
69 | 


--------------------------------------------------------------------------------
/libRedZone/src/Common.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Common.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "Common.h"
 7 | 
 8 | #include <algorithm>
 9 | #include <ctype.h>
10 | #include <functional>
11 | 
12 | #if defined( RZ_UNIX )
13 | #  include <unistd.h>
14 | #elif defined( RZ_WINDOWS )
15 | #  include <Windows.h>
16 | #  include <locale>
17 | #  define snprintf _snprintf
18 | #else
19 | #  error "Unknown OS"
20 | #endif
21 | 
22 | using namespace std;
23 | 
24 | namespace RedZone {
25 | 
26 | std::string dbl2str( double d ) {
27 |     size_t len = snprintf( 0, 0, "%.10f", d );
28 |     std::string s( len + 1, 0) ;
29 |     snprintf( &s[ 0 ], len + 1, "%.10f", d );
30 |     s.pop_back();
31 |     s.erase( s.find_last_not_of( '0' ) + 1, std::string::npos );
32 |     if( s.back() == '.' ) {
33 |         s.pop_back();
34 |     }
35 | 	
36 |     return s;
37 | }
38 | 
39 | void trimString( std::string & str ) {
40 |    str.erase( str.begin(), std::find_if( str.begin(), str.end(),
41 |            std::not1( std::function< int( int ) >( isspace ) ) ) );
42 |    str.erase( std::find_if( str.rbegin(), str.rend(),
43 |            std::not1( std::function< int( int ) >( isspace ) ) ).base(), str.end() );
44 | }
45 | 
46 | std::string replaceString( std::string subject, const std::string & search, const std::string & replace ) {
47 |    size_t pos = 0;
48 |    while ( ( pos = subject.find( search, pos ) ) != std::string::npos ) {
49 |        subject.replace( pos, search.length(), replace );
50 |        pos += replace.length();
51 |    }
52 |    return subject;
53 | }
54 | 
55 | bool isReadableFile( std::string const & filePath ) {
56 | #if defined( RZ_UNIX )
57 |    return access( filePath.c_str(), R_OK ) != -1;
58 | #elif defined( RZ_WINDOWS )
59 | 	DWORD attrs = GetFileAttributes( filePath.c_str() );
60 | 	return ( attrs != INVALID_FILE_ATTRIBUTES && 
61 |          ! ( attrs & FILE_ATTRIBUTE_DIRECTORY ) );
62 | #else
63 | #  error( "Not implemented yet" ) 
64 | #endif
65 | }
66 | 
67 | } /* namespace RedZone */
68 | 


--------------------------------------------------------------------------------
/test.tpl:
--------------------------------------------------------------------------------
 1 | {# Testing inheritance #}
 2 | 
 3 | Before extends
 4 | {% extends middle_test.tpl %}
 5 | {% block mainContent %}
 6 | {# Testing loop and condition tags #}
 7 | {% for item in items %}
 8 |     {% if item.active && length(item.text) == 3 %}
 9 |     <div class="active">{{ item.text }}</div>
10 |     {% else  %}
11 |     <div class="inactive">{{ item.text }}</div>
12 |     {% endif %}
13 | {% endfor %}
14 | 
15 | {# Testing expression parser #}
16 | {{ "f" * 8 + "u" * 8 + "~" }} should be ffffffffuuuuuuuu~
17 | {{upper("f"*8+"u"*8+"~")}} should be FFFFFFFFUUUUUUUU~
18 | {{ sin( 0 )}} should be 0
19 | {{ cos( 0 ) }} should be 1
20 | {{ length( [] ) }} should be 0
21 | {{ length( [ 2, 4, { "s": 55 } ] ) }} should be 3
22 | {{ length( { "key1": "value1", "key2": "value2" } ) }} should be 2
23 | {{ 16 / 4 }} should be 4
24 | {{ get( { "key1": "value1", "key2": "value2" }, "key2" ) }} should be value2
25 | {{ get( numbers, "first" ) }} should be 5
26 | {{ get( numbers, "second" ) }} should be 11
27 | {{ get( numbers, "third" ) }} should be true
28 | {{ get( numbers, "foo" ) }} should be null
29 | {{ ( 2 + 2 ) * (2 + 2) }} should be 16
30 | {{ 2 + " + 2 = 4" }} should be 2 + 2 = 4
31 | {{ contains( "item1", { "item2": [ 2 ], "item1": "str" } ) }} should be true
32 | {{ contains( 2, [ 1, 1, 1, 2, 3, 3 ] ) }} should be true
33 | {{ contains( "ada", "abracadabra" ) }} should be true
34 | {{ to_json( { "key1": "value1", "key2": [ 2, 4, 6] } ) }} should be { "key1": "value1", "key2": [ 2, 4, 6] }
35 | 
36 | {# Testing include tag #}
37 | {% if true %}
38 |     {% include [ "inc_test.tpl" ] %}
39 | {% else %}
40 |     {% include "Fake.tpl" %} 
41 | {% endif %}
42 | 
43 | Numbers:
44 | {% for key,value in numbers %}
45 |    Key: {{ key }}, value: {{ value }}
46 | {% endfor %}
47 | 
48 | {# Testing cache #}
49 | 
50 | {% cache 5000 "TestCache" %}{{ random(20, 100500) }}{% endcache %} should be {% cache 5000 "TestCache" %}{{ random(20, 100500) }}{% endcache %} cached
51 | 
52 | {% endblock %}
53 | 
54 | This text should not be here!
55 | {% endextends %}
56 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/Node.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Node.h
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | #pragma once
 8 | 
 9 | #include <algorithm>
10 | #include <functional>
11 | #include <memory>
12 | #include <vector>
13 | 
14 | #include <Context/json11.hpp>
15 | #include <Export.h>
16 | 
17 | namespace RedZone {
18 | 
19 | class Context;
20 | class Fragment;
21 | class Writer;
22 | 
23 | class RZ_API Node {
24 | public:
25 |    using NodePtr  = std::shared_ptr< Node >;
26 |    using NodeCPtr = std::shared_ptr< Node >;
27 | 
28 |    using Nodes    = std::vector< NodePtr >;
29 | 
30 |    virtual void render( Writer * stream, Context * context ) const;
31 | 
32 |    void renderChildren( Writer * stream, Context * context,
33 |       Nodes children = { } ) const;
34 | 
35 |    virtual void processFragment( Fragment const * fragment );
36 |    void addChild( Node * child );
37 | 
38 |    bool createsScope() const;
39 | 
40 |    virtual void enterScope();
41 |    virtual void exitScope( std::string const & endTag );
42 | 
43 |    virtual std::string name() const;
44 | 
45 |    Nodes const & children();
46 | 
47 |    template< class T >
48 |    std::vector< std::weak_ptr< T > > childrenByName( std::string const & name ) {
49 |       using namespace std;
50 |       Nodes nodes;
51 |       using ResultNode = weak_ptr< T >;
52 |       using ResultNodes = vector< ResultNode >;
53 | 
54 |       copy_if( m_children.begin(), m_children.end(), back_inserter( nodes ),
55 |          bind( equal_to< string >(), bind( &Node::name, placeholders::_1 ), name ) );
56 |       ResultNodes result;
57 |       for( auto & node : nodes )
58 |       {
59 |          result.push_back( weak_ptr< T >( dynamic_pointer_cast< T >( node ) ) );
60 |       }
61 |       return result;
62 |    }
63 | 
64 |    virtual ~Node();
65 | 
66 | protected:
67 |    Node( bool createsScope = false );
68 |    virtual json11::Json resolveInContext( std::string const & name, Context const * context ) const;
69 | 
70 | protected:
71 |    Nodes m_children;
72 |    bool m_createsScope;
73 | };
74 | 
75 | } /* namespace RedZone */
76 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 2.6)
 2 | 
 3 | project(RedZoneTest)
 4 | 
 5 | if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
 6 | 	# turn on C++11 features
 7 | 	set(CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
 8 | endif(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
 9 | 
10 | set(RZT_SOURCES
11 |     main.cpp
12 | )
13 | 
14 | set(RZT_HEADERS
15 | )
16 | 
17 | add_subdirectory(libRedZone)
18 | 
19 | include_directories(${RedZone_SOURCE_DIR}/src)
20 | 
21 | add_executable(RedZoneTest ${RZT_SOURCES} ${RZT_HEADERS})
22 | 
23 | target_link_libraries(RedZoneTest RedZone)
24 | 
25 | configure_file(test.tpl test.tpl COPYONLY)
26 | configure_file(inc_test.tpl inc_test.tpl COPYONLY)
27 | configure_file(test.json test.json COPYONLY)
28 | configure_file(base_test.tpl base_test.tpl COPYONLY)
29 | configure_file(middle_test.tpl middle_test.tpl COPYONLY)
30 | 
31 | 
32 | # building language extension
33 | 
34 | if(DEFINED BUILD_LANG_EXTENSION)
35 | 
36 |     if(${BUILD_LANG_EXTENSION} MATCHES "python")
37 |         set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_LIST_DIR}/cmake )
38 |     
39 |         include( UseCython )
40 |         
41 |         set_source_files_properties(
42 |             cython/RedZone.pyx
43 |             PROPERTIES CYTHON_IS_CXX TRUE
44 |         )
45 |         cython_add_module(PyRedZone cython/RedZone.pyx)
46 |         target_link_libraries(PyRedZone RedZone)
47 |         target_link_libraries(PyRedZone ${PYTHON_LIBRARIES})
48 |         set_target_properties(PyRedZone PROPERTIES PREFIX "")
49 |         set_target_properties(PyRedZone PROPERTIES OUTPUT_NAME "RedZone")
50 |         
51 |         configure_file(cython/test.py test.py COPYONLY)
52 |         
53 |         if(WIN32)
54 |             # Prevent coercive linking to pythonXX.lib (via the preprocessor directive pragma comment(lib, ...))
55 |             # add_definitions(-DMS_NO_COREDLL)
56 |         endif(WIN32)
57 |         
58 |     endif(${BUILD_LANG_EXTENSION} MATCHES "python")
59 |     
60 |     # TODO: add extensions for other languages
61 | 
62 | endif(DEFINED BUILD_LANG_EXTENSION)
63 | 


--------------------------------------------------------------------------------
/libRedZone/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 2.6)
 2 | 
 3 | project(RedZone)
 4 | 
 5 | # turn on C++11 features
 6 | set(CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS} -g -ftest-coverage -fprofile-arcs")
 7 | 
 8 | set(RZ_SOURCES
 9 |     src/Common.cpp
10 |     src/Context/Context.cpp
11 |     src/Context/json11.cpp
12 |     src/Exception/Exception.cpp
13 |     src/Exception/ExpressionException.cpp
14 |     src/Exception/IOError.cpp
15 |     src/Exception/JsonError.cpp
16 |     src/Exception/TemplateContextError.cpp
17 |     src/Exception/TemplateSyntaxError.cpp
18 |     src/IO/FileReader.cpp
19 |     src/IO/FileWriter.cpp
20 |     src/IO/Reader.cpp
21 |     src/IO/StringReader.cpp
22 |     src/IO/StringWriter.cpp
23 |     src/IO/Writer.cpp
24 |     src/Node/BlockNode.cpp
25 | 	src/Node/CacheNode.cpp
26 |     src/Node/EachNode.cpp
27 |     src/Node/ElseNode.cpp
28 |     src/Node/ExtendsNode.cpp
29 |     src/Node/IfNode.cpp
30 |     src/Node/IncludeNode.cpp
31 |     src/Node/Node.cpp
32 |     src/Node/Root.cpp
33 |     src/Node/TextNode.cpp
34 |     src/Node/Variable.cpp
35 |     src/Parser/ExpressionParser.cpp
36 |     src/Parser/Fragment.cpp
37 |     src/Parser/Parser.cpp
38 |     src/Template/FileTemplate.cpp
39 |     src/Template/Template.cpp
40 | )
41 | 
42 | set(RZ_HEADERS
43 |     src/Common.h
44 |     src/Context/Context.h
45 |     src/Context/json11.hpp
46 |     src/Exception/Exception.h
47 |     src/Exception/ExpressionException.h
48 |     src/Exception/IOError.h
49 |     src/Exception/JsonError.h
50 |     src/Exception/TemplateContextError.h
51 |     src/Exception/TemplateSyntaxError.h
52 |     src/IO/FileReader.h
53 |     src/IO/FileWriter.h
54 |     src/IO/Reader.h
55 |     src/IO/StringReader.h
56 |     src/IO/StringWriter.h
57 |     src/IO/Writer.h
58 | 	src/Node/BlockNode.h
59 | 	src/Node/CacheNode.h
60 |     src/Node/EachNode.h
61 |     src/Node/ElseNode.h
62 |     src/Node/ExtendsNode.h
63 |     src/Node/IfNode.h
64 |     src/Node/IncludeNode.h
65 |     src/Node/Node.h
66 |     src/Node/Root.h
67 |     src/Node/TextNode.h
68 |     src/Node/Variable.h
69 |     src/Parser/ExpressionParser.h
70 |     src/Parser/Fragment.h
71 |     src/Parser/Parser.h
72 |     src/Template/FileTemplate.h
73 |     src/Template/Template.h
74 | )
75 | 
76 | option(BUILD_RZ_SHARED "Build RedZone shared library." ON)
77 | 
78 | include_directories(src)
79 | 
80 | if(BUILD_RZ_SHARED)
81 |     set(RZ_LIBRARY_TYPE SHARED)
82 |     message(STATUS "Building shared library")
83 | else(BUILD_RZ_SHARED)
84 |     set(RZ_LIBRARY_TYPE STATIC)
85 |     message(STATUS "Building static library")
86 | endif(BUILD_RZ_SHARED)
87 | 
88 | add_definitions(-DRZ_EXPORTS)
89 | 
90 | add_library(RedZone ${RZ_LIBRARY_TYPE} ${RZ_SOURCES})
91 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/EachNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * EachNode.cpp
 3 |  *
 4 |  *  Created on: 2014
 5 |  *      Author: jc
 6 |  */
 7 | 
 8 | #include "EachNode.h"
 9 | 
10 | #include <iostream>
11 | #include <regex>
12 | 
13 | #include <Common.h>
14 | #include <Context/Context.h>
15 | #include <Exception/TemplateSyntaxError.h>
16 | #include <Parser/ExpressionParser.h>
17 | #include <Parser/Fragment.h>
18 | 
19 | using namespace json11;
20 | 
21 | namespace RedZone {
22 | 
23 | EachNode::EachNode()
24 |    : Node( true ) {
25 | }
26 | 
27 | void EachNode::render( Writer * stream, Context * context ) const {
28 |    ExpressionParser parser( context );
29 |    Json container = parser.parse( m_container );
30 |    if( !( container.is_array() || container.is_object() ) ) {
31 |       throw Exception( container.dump() + " is not iterable" );
32 |    }
33 | 
34 |    Json::object prototype = context->json().object_items();
35 | 
36 |    std::shared_ptr< Context > newContext( new Context( prototype ) );
37 |    if( container.type() == Json::ARRAY ) {
38 |       Json::array items = container.array_items();
39 |       for( auto const & item: items ) {
40 |          prototype[ m_vars[ 0 ] ] = item;
41 |          newContext->setJson( Json( prototype ) );
42 |          renderChildren( stream, newContext.get() );
43 |       }
44 |    } else if( container.type() == Json::OBJECT ) {
45 |       Json::object items = container.object_items();
46 |       for( auto const & item: items ) {
47 |          prototype[ m_vars[ 0 ] ] = item.first;
48 |          if( m_vars.size() > 1 ) {
49 |             prototype[ m_vars[ 1 ] ] = item.second;
50 |          }
51 |          newContext->setJson( Json( prototype ) );
52 |          renderChildren( stream, newContext.get() );
53 |       }
54 |    }
55 | }
56 | 
57 | void EachNode::processFragment( Fragment const * fragment ) {
58 |    static std::regex const splitter( R"(^for\s+(\w[a-zA-Z0-9 _,]*) \s*in\s+(.+)$)" );
59 |    std::smatch match;
60 |    std::string cleaned = fragment->clean();
61 |    if( !std::regex_match( cleaned, match, splitter ) ) {
62 |       throw TemplateSyntaxError( fragment->clean() );
63 |    }
64 |    std::string vars = match[ 1 ];
65 |    static std::regex const varNameExtractor( R"(\s*,\s*)" );
66 |    std::sregex_token_iterator varNamesIter( vars.begin(), vars.end(), varNameExtractor, -1 );
67 |    std::vector< std::string > possibleVars;
68 |    static std::sregex_token_iterator const end;
69 |    std::copy( varNamesIter, end, std::back_inserter( possibleVars ) );
70 |    if( std::find( possibleVars.begin(), possibleVars.end(), "" ) != possibleVars.end() ) {
71 |       throw TemplateSyntaxError( vars );
72 |    }
73 |    m_vars = possibleVars;
74 |    m_container = match[ 2 ];
75 | }
76 | 
77 | void EachNode::exitScope( std::string const & endTag ) {
78 |    if( endTag != "endfor" )
79 |       throw TemplateSyntaxError( endTag );
80 | }
81 | 
82 | std::string EachNode::name() const {
83 |    return "For";
84 | }
85 | 
86 | EachNode::~EachNode() {
87 | }
88 | 
89 | } /* namespace RedZone */
90 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/IncludeNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * IncludeNode.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "IncludeNode.h"
 7 | 
 8 | #include <algorithm>
 9 | #include <functional>
10 | #include <memory>
11 | #include <regex>
12 | 
13 | #include <Common.h>
14 | #include <Exception/Exception.h>
15 | #include <Exception/TemplateSyntaxError.h>
16 | #include <IO/FileReader.h>
17 | #include <Parser/ExpressionParser.h>
18 | #include <Parser/Fragment.h>
19 | #include <Parser/Parser.h>
20 | 
21 | #include "Root.h"
22 | 
23 | using namespace json11;
24 | using namespace std::placeholders;
25 | 
26 | namespace RedZone {
27 | 
28 | IncludeNode::IncludeNode()
29 |    : Node( false ) {
30 | 
31 | }
32 | 
33 | // Yeah... Render-time parsing.
34 | void IncludeNode::render( Writer * stream, Context * context ) const {
35 |    ExpressionParser exprParser( context );
36 |    Json paths = exprParser.parse( m_includeExpr );
37 |    std::vector< std::string > const & allParserPaths = Parser::paths();
38 |    std::string const wrongArgumentError =
39 |       "Include expression \"" + m_includeExpr + "\" must be single string or array of strings.";
40 |    auto rootCreator = [ & ]( std::string path ) -> std::shared_ptr< Root > {
41 |       auto found = std::find_if( allParserPaths.begin(), allParserPaths.end(),
42 |          std::bind( &isReadableFile, std::bind(
43 |             std::function< std::string( std::string const &, std::string const & ) >( strConcat ), _1, path ) ) );
44 |       if( found == allParserPaths.end() ) {
45 |          throw Exception(  "Include failed. Cannot open template file " + path );
46 |       }
47 |       path = *found + path;
48 |       FileReader reader( path );  // FIXME: get rid of specific Reader creating
49 |       static Parser parser;
50 |       return std::shared_ptr< Root >( parser.loadFromStream( &reader ) );
51 |    };
52 |    std::vector< std::shared_ptr< Root > > roots;
53 |    if( paths.is_string() ) {
54 |       roots.push_back( rootCreator( paths.string_value() ) );
55 |    } else if( paths.is_array() ) {
56 |       Json::array const & allPaths = paths.array_items();
57 |       if( std::any_of( allPaths.begin(), allPaths.end(),
58 |              std::bind( std::equal_to< bool >(), std::bind( &Json::is_string, _1 ), false ) ) ) {
59 |          throw Exception( wrongArgumentError ); // Some elements in array do not have string type
60 |       }
61 |       std::transform( allPaths.begin(), allPaths.end(), std::back_inserter( roots ),
62 |          std::bind( rootCreator, std::bind( &Json::string_value, _1 ) ) );
63 |    } else {
64 |       throw Exception( wrongArgumentError );
65 |    }
66 |    std::for_each( roots.begin(), roots.end(), std::bind( &Root::render, _1, stream, context ) );
67 | }
68 | 
69 | void IncludeNode::processFragment( Fragment const * fragment ) {
70 |    static std::regex splitter( R"(^include\s+(.+))" );
71 |    std::smatch match;
72 |    std::string cleaned = fragment->clean();
73 |    if( !std::regex_match( cleaned, match, splitter ) ) {
74 |          throw TemplateSyntaxError( fragment->clean() );
75 |    }
76 |    m_includeExpr = match[ 1 ];
77 | }
78 | 
79 | std::string IncludeNode::name() const {
80 |    return "Include";
81 | }
82 | 
83 | IncludeNode::~IncludeNode() {
84 | }
85 | 
86 | } /* namespace RedZone */
87 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/ExtendsNode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * ExtendsNode.cpp
 3 |  *
 4 |  *      Author: jc
 5 |  */
 6 | #include "ExtendsNode.h"
 7 | 
 8 | #include <algorithm>
 9 | #include <functional>
10 | #include <regex>
11 | 
12 | #include <Common.h>
13 | #include <Exception/TemplateSyntaxError.h>
14 | #include <IO/FileReader.h>
15 | #include <Parser/Fragment.h>
16 | #include <Parser/Parser.h>
17 | 
18 | #include "BlockNode.h"
19 | #include "Root.h"
20 | 
21 | using namespace std::placeholders;
22 | 
23 | namespace RedZone {
24 | 
25 | ExtendsNode::ExtendsNode() :
26 |    Node( true ) {
27 | }
28 | 
29 | void ExtendsNode::render( Writer * stream, Context * context ) const {
30 |    renderChildren( stream, context, m_nodesToRender );
31 | }
32 | 
33 | void ExtendsNode::processFragment( Fragment const * fragment ) {
34 |    static std::regex const splitter( R"(^extends\s+(.+)$)" );
35 |    std::smatch match;
36 |    std::string cleaned = fragment->clean();
37 |    if( ! std::regex_match( cleaned, match, splitter ) ) {
38 |       throw TemplateSyntaxError( fragment->clean() );
39 |    }
40 |    std::string path = match[ 1 ];
41 |    std::vector< std::string > const & allParserPaths = Parser::paths();
42 |    auto found = std::find_if( allParserPaths.begin(), allParserPaths.end(),
43 |       std::bind( &isReadableFile, std::bind(
44 |          std::function< std::string( std::string const &, std::string const & ) >( strConcat ), _1, path ) ) );
45 |    if( found == allParserPaths.end() ) {
46 |       throw Exception( "Extending failed. Cannot open template file " + path );
47 |    }
48 |    path = *found + path;
49 |    FileReader reader( path );  // FIXME: get rid of specific Reader creating
50 |    static Parser parser;
51 |    m_parentRoot.reset( parser.loadFromStream( &reader ) );
52 | }
53 | 
54 | void ExtendsNode::exitScope( std::string const & endTag ) {
55 |    if( endTag != "endextends" )
56 |       throw TemplateSyntaxError( endTag );
57 | 
58 |    auto extendsNodes = m_parentRoot->childrenByName< ExtendsNode >( name() );
59 |    if( extendsNodes.size() > 1 )
60 |       throw Exception( "Parent template has more than one 'extends' blocks" );
61 |    if( extendsNodes.size() && m_parentRoot->children()[ 0 ]->name() != name() )
62 |       throw Exception( "Extends node must be the first in " + m_parentRoot->id() );
63 |    std::vector< std::shared_ptr< Node > > parentChildNodes;
64 |    if( extendsNodes.size() ) {
65 |       parentChildNodes = weakToShared( extendsNodes[ 0 ] )->m_nodesToRender;
66 |    }
67 |    else {
68 |       parentChildNodes = m_parentRoot->children();
69 |    }
70 |    auto blocks = childrenByName< BlockNode >( "Block" );
71 |    for( std::shared_ptr< Node > node: parentChildNodes ) {
72 |       if( node->name() == "Block" ) {
73 |          std::shared_ptr< BlockNode > blockNode = std::dynamic_pointer_cast< BlockNode >( node );
74 |          std::string blockName = blockNode->blockName();
75 |          auto found = std::find_if( blocks.begin(), blocks.end(),
76 |             [ & ]( auto block ) -> bool { return blockName == weakToShared( block )->blockName(); } );
77 |          if( found != blocks.end() ) {
78 |             m_nodesToRender.push_back( 
79 |                std::dynamic_pointer_cast< Node >( weakToShared( * found ) ) );
80 |             continue;
81 |          }
82 |          m_nodesToRender.push_back( node );
83 |       }
84 |       else {
85 |          m_nodesToRender.push_back( node );
86 |       }
87 |    }
88 | }
89 | 
90 | std::string ExtendsNode::name() const {
91 |    return "Extends";
92 | }
93 | 
94 | ExtendsNode::~ExtendsNode() {
95 | }
96 | 
97 | } /* namespace RedZone */
98 | 


--------------------------------------------------------------------------------
/libRedZone/src/Node/CacheNode.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * CacheNode.cpp
  3 |  *
  4 |  *  Created on: 2015
  5 |  *      Author: jc
  6 |  */
  7 | #include "CacheNode.h"
  8 | 
  9 | #include <iostream>
 10 | #include <ctime>
 11 | #include <functional>
 12 | #include <regex>
 13 | 
 14 | #include <Common.h>
 15 | #include <Context/Context.h>
 16 | #include <Exception/TemplateSyntaxError.h>
 17 | #include <IO/StringWriter.h>
 18 | #include <Parser/ExpressionParser.h>
 19 | #include <Parser/Fragment.h>
 20 | 
 21 | using namespace json11;
 22 | 
 23 | namespace RedZone {
 24 | 
 25 | std::unordered_map< size_t, CacheNode::CacheRow > CacheNode::s_cached;
 26 | 
 27 | CacheNode::CacheNode()
 28 |    : Node( true ) {
 29 | }
 30 | 
 31 | void CacheNode::render( Writer * stream, Context * context ) const {
 32 |    ExpressionParser parser( context );
 33 |    
 34 |    size_t hashValue = 1;
 35 |    static auto hashFunc = std::hash< std::string >();
 36 | 
 37 |    for( auto varName: m_vars ) {
 38 |       Json var = parser.parse( varName );
 39 |       hashValue ^= hashFunc( var.dump() );
 40 |    }
 41 | 
 42 |    auto now = std::chrono::system_clock::now();
 43 |    auto found = s_cached.find( hashValue );
 44 | 
 45 |    auto renderChldrn = [ = ]() -> std::string {
 46 |       std::string rendered;
 47 |       StringWriter writer( rendered );
 48 |       renderChildren( & writer, context );
 49 |       return rendered;
 50 |    };
 51 |    std::string rendered;
 52 |    if( found == s_cached.end() ) {
 53 |       // insert new element into the cache.
 54 |       rendered = renderChldrn();
 55 |       s_cached[ hashValue ] = std::make_tuple( now, rendered );
 56 |    }
 57 |    else
 58 |    {
 59 |       // element found. Update if necessary.
 60 |       auto row = found->second;
 61 |       auto timePoint = std::get< 0 >( row );
 62 |       auto elapsedMSec = std::chrono::duration_cast< std::chrono::milliseconds >( now - timePoint ).count();
 63 |       if( elapsedMSec >= m_cacheTime )
 64 |       {
 65 |          // re-render
 66 |          rendered = renderChldrn();
 67 |          s_cached[ hashValue ] = std::make_tuple( now, rendered );
 68 |       }
 69 |       else
 70 |       {
 71 |          rendered = std::get< 1 >( row );
 72 |       }
 73 |    }
 74 |    stream->write( rendered );
 75 | }
 76 | 
 77 | void CacheNode::processFragment( Fragment const * fragment ) {
 78 |    static std::regex const splitter( R"(^cache\s+(\d+)\s+(.+)$)" );
 79 |    std::smatch match;
 80 |    std::string cleaned = fragment->clean();
 81 |    if( ! std::regex_match( cleaned, match, splitter ) ) {
 82 |       throw TemplateSyntaxError( cleaned );
 83 |    }
 84 |    std::string cacheTimeStr = match[ 1 ];
 85 |    m_cacheTime = std::stol( cacheTimeStr );
 86 |    std::string varsStr = match[ 2 ];
 87 | 
 88 |    static std::regex const varNameExtractor( R"(\s+)" );
 89 |    std::sregex_token_iterator varNamesIter( varsStr.begin(), varsStr.end(), varNameExtractor, -1 );
 90 |    m_vars.clear();
 91 |    std::vector< std::string > possibleVars;
 92 |    static std::sregex_token_iterator const end;
 93 |    std::copy( varNamesIter, end, std::back_inserter( possibleVars ) );
 94 |    if( std::find( possibleVars.begin(), possibleVars.end(), "" ) != possibleVars.end() ) {
 95 |       throw TemplateSyntaxError( varsStr );
 96 |    }
 97 |    m_vars = possibleVars;
 98 | }
 99 | 
100 | void CacheNode::exitScope( std::string const & endTag ) {
101 |    if( endTag != "endcache" )
102 |       throw TemplateSyntaxError( endTag );
103 | }
104 | 
105 | std::string CacheNode::name() const {
106 |    return "Cache";
107 | }
108 | 
109 | CacheNode::~CacheNode() {
110 | }
111 | 
112 | } /* namespace RedZone */
113 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/Parser.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Parser.cpp
  3 |  *
  4 |  *  Created on: 2014
  5 |  *      Author: jc
  6 |  */
  7 | 
  8 | #include "Parser.h"
  9 | 
 10 | #include <iostream>
 11 | #include <regex>
 12 | #include <stack>
 13 | #include <utility>
 14 | 
 15 | #include <Common.h>
 16 | #include <Exception/Exception.h>
 17 | #include <Exception/TemplateSyntaxError.h>
 18 | #include <IO/Reader.h>
 19 | #include <Node/BlockNode.h>
 20 | #include <Node/CacheNode.h>
 21 | #include <Node/EachNode.h>
 22 | #include <Node/ElseNode.h>
 23 | #include <Node/ExtendsNode.h>
 24 | #include <Node/IfNode.h>
 25 | #include <Node/IncludeNode.h>
 26 | #include <Node/Root.h>
 27 | #include <Node/TextNode.h>
 28 | #include <Node/Variable.h>
 29 | 
 30 | #include "Fragment.h"
 31 | 
 32 | namespace RedZone {
 33 | 
 34 | const std::map<
 35 |         std::string, std::function< Node * () >
 36 |         > Parser::s_nodeCreators {
 37 |     { R"(^if\s+.*$)",                                 []() { return new IfNode();      } },
 38 |     { R"(^else$)",                                    []() { return new ElseNode();    } },
 39 |     { R"(^for\s+\w[a-zA-Z0-9 _,]* \s*in\s+.+$)",      []() { return new EachNode();    } },
 40 |     { R"(^include\s+.+$)",                            []() { return new IncludeNode(); } },
 41 |     { R"(^block\s+\w+$)",                             []() { return new BlockNode();   } },
 42 |     { R"(^extends\s+.+$)",                            []() { return new ExtendsNode(); } },
 43 |     { R"(^cache\s+\d+\s+.+)",                         []() { return new CacheNode();   } },
 44 | };
 45 | 
 46 | std::vector< std::string > Parser::s_paths { "./", };
 47 | 
 48 | Parser::Parser() {
 49 | 
 50 | }
 51 | 
 52 | Root * Parser::loadFromStream( Reader * stream ) const {
 53 | 
 54 |    static std::string commentExpr = ( []() -> std::string {
 55 |       std::string result = "(" COMMENT_START_TOKEN ".*?" COMMENT_END_TOKEN ")";
 56 |       result = replaceString( result, "{", "\\{" );
 57 |       result = replaceString( result, "}", "\\}" );
 58 |       return result;
 59 |    } )();
 60 | 
 61 |    static std::regex const commentMatcher( commentExpr );
 62 | 
 63 |    static std::string splitExpr = ( []() -> std::string {
 64 |       std::string result = "(" VAR_START_TOKEN ".*?" VAR_END_TOKEN "|"
 65 |          BLOCK_START_TOKEN ".*?" BLOCK_END_TOKEN ")";
 66 |       result = replaceString( result, "{", "\\{" );
 67 |       result = replaceString( result, "}", "\\}" );
 68 |       return result;
 69 |    } )();
 70 | 
 71 |    static std::regex const tokenSplitter( splitExpr );
 72 | 
 73 |    std::vector< std::shared_ptr< Fragment > > fragments;
 74 |    std::string templateSrc = stream->readAll();
 75 | 
 76 |    templateSrc = std::regex_replace( templateSrc, commentMatcher, "" );
 77 | 
 78 |    std::sregex_token_iterator iter(
 79 |       templateSrc.begin(), templateSrc.end(), tokenSplitter, std::vector< int >{ -1, 0 } );
 80 |    static std::sregex_token_iterator const end;
 81 |    for( ; iter != end; ++iter ) {
 82 |       if( !( *iter ).length() ) {
 83 |           continue;
 84 |       }
 85 |       fragments.push_back( std::make_shared< Fragment >( *iter ) );
 86 |    }
 87 | 
 88 |    Root * root( new Root( stream->id() ) );
 89 | 
 90 |    std::stack< Node * > scopeStack;
 91 |    scopeStack.push( root );
 92 | 
 93 |    for( auto fragment: fragments ) {
 94 |       if( !scopeStack.size() ) {
 95 |          throw Exception( "nesting issues" );
 96 |       }
 97 | 
 98 |       auto parentScope = scopeStack.top();
 99 |       if( fragment->type() == ElementType::CloseBlockFragment ) {
100 |          parentScope->exitScope( fragment->clean() );
101 |          scopeStack.pop();
102 |          continue;
103 |       }
104 | 
105 |       auto newNode = createNode( fragment.get() );
106 |       parentScope->addChild( newNode );
107 |       if( newNode->createsScope() ) {
108 |          scopeStack.push( newNode );
109 |          newNode->enterScope();
110 |       }
111 |    }
112 |    if( scopeStack.size() > 1 ) {
113 |       throw Exception( "There is non-closed tag " + scopeStack.top()->name() );
114 |    }
115 |    return root;
116 | }
117 | 
118 | Node * Parser::createNode( Fragment const * fragment ) const {
119 |     Node * node = nullptr;
120 |     switch( fragment->type() ) {
121 |     case ElementType::TextFragment:
122 |         node = new TextNode();
123 |         break;
124 |     case ElementType::VarElement:
125 |         node = new Variable();
126 |         break;
127 |     case ElementType::OpenBlockFragment: {
128 |             auto finder = [ fragment ]( std::pair< std::string, std::function< Node * () > > value ) {
129 |                     return std::regex_search( fragment->clean(), std::regex( value.first ) ); };
130 |             auto found = std::find_if( s_nodeCreators.begin(), s_nodeCreators.end(), finder );
131 |             if( found == s_nodeCreators.end() ) {
132 |                 throw TemplateSyntaxError( fragment->clean() );
133 |             }
134 |             node = found->second();
135 |         }
136 |         break;
137 |     default:
138 |         throw TemplateSyntaxError( fragment->clean() );
139 |     }
140 |     node->processFragment( fragment );
141 |     return node;
142 | }
143 | 
144 | void Parser::addPath( std::string path ) {
145 |    path = replaceString( path, "\\", "/" );
146 |    if ( path.back() != '/' )
147 |       path.push_back( '/' );
148 |    s_paths.push_back( path );
149 | }
150 | 
151 | std::vector< std::string > const & Parser::paths() {
152 |    return s_paths;
153 | }
154 | 
155 | Parser::~Parser() {
156 | }
157 | 
158 | } /* namespace RedZone */
159 | 


--------------------------------------------------------------------------------
/cython/RedZone.pyx:
--------------------------------------------------------------------------------
  1 | from libcpp cimport bool
  2 | from libcpp.map cimport map
  3 | from libcpp.vector cimport vector
  4 | from libcpp.string cimport string
  5 | 
  6 | 
  7 | # class mapping
  8 | 
  9 | 
 10 | cdef extern from "<Context/json11.hpp>" namespace "json11":
 11 | 
 12 |     cdef cppclass CJson "json11::Json":
 13 |         CJson()
 14 |         CJson( CJson & )
 15 |         CJson( double value )
 16 |         CJson( int value )
 17 |         CJson( bool value )
 18 |         CJson( string & value )
 19 |         CJson( char * value )
 20 |         CJson( vector[ CJson ] value )
 21 |         CJson( map[ string, CJson ] value)
 22 | 
 23 |         string dump()
 24 | 
 25 |         bool is_number()
 26 |         bool is_bool()
 27 |         bool is_object()
 28 |         bool is_string()
 29 |         bool is_array()
 30 | 
 31 |         double number_value()
 32 |         int int_value()
 33 |         bool bool_value()
 34 |         string string_value()
 35 |         vector[ CJson ] array_items()
 36 |         map[ string, CJson ] object_items()
 37 | 
 38 | 
 39 | cdef extern from "<Context/json11.hpp>" namespace "json11::Json":
 40 |     CJson parse( char *, string & )
 41 | 
 42 | 
 43 | cdef extern from "<Context/Context.h>" namespace "RedZone":
 44 |     cdef cppclass CContext "RedZone::Context":
 45 |         CContext( string & json )
 46 | 
 47 |         CContext( CJson & json ) except +
 48 | 
 49 |         CJson json()
 50 |         void setJson( CJson & json ) except +
 51 |         CJson resolve( string & name ) except +
 52 | 
 53 | 
 54 | cdef extern from "<IO/Reader.h>" namespace "RedZone":
 55 |     cdef cppclass CReader "RedZone::Reader":
 56 |         string read( size_t nBytes )
 57 |         string readAll()
 58 | 
 59 | 
 60 | cdef extern from "<IO/FileReader.h>" namespace "RedZone":
 61 |     cdef cppclass CFileReader "RedZone::FileReader" ( CReader ):
 62 |         CFileReader( string fileName ) except +
 63 |         string read( size_t nBytes )
 64 |         string readAll()
 65 | 
 66 | 
 67 | cdef extern from "<IO/StringReader.h>" namespace "RedZone":
 68 |     cdef cppclass CStringReader "RedZone::StringReader" ( CReader ):
 69 |         CStringReader( string & dataString )
 70 |         string read( size_t nBytes )
 71 |         string readAll()
 72 | 
 73 | 
 74 | cdef extern from "<IO/Writer.h>" namespace "RedZone":
 75 |     cdef cppclass CWriter "RedZone::Writer":
 76 |         void write( string & data )
 77 |         void flush()
 78 | 
 79 | 
 80 | cdef extern from "<IO/FileWriter.h>" namespace "RedZone":
 81 |     cdef cppclass CFileWriter "RedZone::FileWriter" ( CWriter ):
 82 |         CFileWriter( string & fileName ) except +
 83 |         void write( string & data )
 84 |         void flush()
 85 | 
 86 | 
 87 | cdef extern from "<IO/StringWriter.h>" namespace "RedZone":
 88 |     cdef cppclass CStringWriter "RedZone::StringWriter" ( CWriter ):
 89 |         CStringWriter( string & dataString ) except +
 90 |         void write( string & data )
 91 |         void flush()
 92 | 
 93 | 
 94 | cdef extern from "<Template/Template.h>" namespace "RedZone":
 95 |     cdef cppclass CTemplate "RedZone::Template":
 96 |         void renderToStream( CWriter * stream, CContext * context ) except +
 97 |         string render( CContext * context ) except +
 98 | 
 99 | 
100 | cdef extern from "<Template/FileTemplate.h>" namespace "RedZone":
101 |     cdef cppclass CFileTemplate "RedZone::FileTemplate" ( CTemplate ):
102 |         CFileTemplate( string & fileName )
103 | 
104 | 
105 | # class wrapping
106 | 
107 | 
108 | cdef class Context:
109 |     cdef CContext * thisptr
110 | 
111 |     def __cinit__( self, dict json ):
112 |         strJson = str( json )
113 |         strJson = strJson.replace("'", '"')\
114 |             .replace( "True", "true" )\
115 |             .replace( "False", "false" )\
116 |             .replace( "None", "null" )
117 |         cdef string err
118 |         cdef CJson cjson = parse( strJson, err )
119 |         if err.length():
120 |             raise RuntimeError( "Cannot parse json: " + err )
121 |         self.thisptr = new CContext( cjson )
122 | 
123 | 
124 |     property data:
125 |         """
126 |         Context data property, must always be dict.
127 |         """
128 |         def __get__( self ):
129 |             jsonStr = self.thisptr.json().dump()
130 |             jsonStr = jsonStr.replace( "true", "True" )\
131 |                 .replace( "false", "False" )\
132 |                 .replace( "null", "None" )
133 |             return eval( jsonStr )  # FIXME: doesn't seem so good
134 | 
135 |         def __set__( self, dict json ):
136 |             strJson = str( json )
137 |             strJson = strJson.replace("'", '"')\
138 |                 .replace( "True", "true" )\
139 |                 .replace( "False", "false" )\
140 |                 .replace( "None", "null" )
141 |             cdef string err
142 |             cdef CJson cjson = parse( strJson, err )
143 |             if err.length():
144 |                 raise RuntimeError( "Cannot parse json: " + err )
145 |             self.thisptr.setJson( parse( strJson, err ) )
146 | 
147 | 
148 | cdef class Writer:
149 |     cdef CWriter * thisptr
150 | 
151 |     def write( self, string data ):
152 |         self.thisptr.write( data )
153 | 
154 |     def flush( self ):
155 |         self.thisptr.flush()
156 | 
157 | 
158 | cdef class FileWriter(Writer):
159 |     def __cinit__( self, string fileName ):
160 |         self.thisptr = new CFileWriter( fileName )
161 | 
162 | 
163 | cdef class StringWriter(Writer):
164 |     def __cinit__( self, string & data ):
165 |         self.thisptr = new CStringWriter( data )
166 | 
167 | 
168 | cdef class Template:
169 |     cdef CTemplate * thisptr
170 | 
171 |     def renderToStream( self, Writer stream, Context context ):
172 |         self.thisptr.renderToStream( stream.thisptr, context.thisptr )
173 | 
174 |     def render( self, Context context ):
175 |         return self.thisptr.render( context.thisptr )
176 | 
177 | cdef class FileTemplate( Template ):
178 |     def __cinit__( self, string fileName ):
179 |         self.thisptr = new CFileTemplate( fileName )
180 | 


--------------------------------------------------------------------------------
/libRedZone/src/Context/json11.hpp:
--------------------------------------------------------------------------------
  1 | /* json11
  2 |  *
  3 |  * json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
  4 |  *
  5 |  * The core object provided by the library is json11::Json. A Json object represents any JSON
  6 |  * value: null, bool, number (int or double), string (std::string), array (std::vector), or
  7 |  * object (std::map).
  8 |  *
  9 |  * Json objects act like values: they can be assigned, copied, moved, compared for equality or
 10 |  * order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and
 11 |  * Json::parse (static) to parse a std::string as a Json object.
 12 |  *
 13 |  * Internally, the various types of Json object are represented by the JsonValue class
 14 |  * hierarchy.
 15 |  *
 16 |  * A note on numbers - JSON specifies the syntax of number formatting but not its semantics,
 17 |  * so some JSON implementations distinguish between integers and floating-point numbers, while
 18 |  * some don't. In json11, we choose the latter. Because some JSON implementations (namely
 19 |  * Javascript itself) treat all numbers as the same type, distinguishing the two leads
 20 |  * to JSON that will be *silently* changed by a round-trip through those implementations.
 21 |  * Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also
 22 |  * provides integer helpers.
 23 |  *
 24 |  * Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the
 25 |  * range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64
 26 |  * or long long to avoid the Y2038K problem; a double storing microseconds since some epoch
 27 |  * will be exact for +/- 275 years.)
 28 |  */
 29 | 
 30 | /* Copyright (c) 2013 Dropbox, Inc.
 31 |  *
 32 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 33 |  * of this software and associated documentation files (the "Software"), to deal
 34 |  * in the Software without restriction, including without limitation the rights
 35 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 36 |  * copies of the Software, and to permit persons to whom the Software is
 37 |  * furnished to do so, subject to the following conditions:
 38 |  *
 39 |  * The above copyright notice and this permission notice shall be included in
 40 |  * all copies or substantial portions of the Software.
 41 |  *
 42 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 43 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 44 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 45 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 46 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 47 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 48 |  * THE SOFTWARE.
 49 |  */
 50 | 
 51 | #pragma once
 52 | 
 53 | #include <string>
 54 | #include <vector>
 55 | #include <map>
 56 | #include <memory>
 57 | #include <initializer_list>
 58 | 
 59 | #ifdef _MSC_VER
 60 | #define JSON11_NOEXCEPT
 61 | #else
 62 | #define JSON11_NOEXCEPT noexcept
 63 | #endif
 64 | 
 65 | #include <Export.h>
 66 | 
 67 | namespace json11 {
 68 | 
 69 | class JsonValue;
 70 | 
 71 | class RZ_API Json final {
 72 | public:
 73 |     // Types
 74 |     enum Type {
 75 |         NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
 76 |     };
 77 | 
 78 |     // Array and object typedefs
 79 |     typedef std::vector<Json> array;
 80 |     typedef std::map<std::string, Json> object;
 81 | 
 82 |     // Constructors for the various types of JSON value.
 83 |     Json() JSON11_NOEXCEPT;                // NUL
 84 |     Json(std::nullptr_t) JSON11_NOEXCEPT;  // NUL
 85 |     Json(double value);                    // NUMBER
 86 |     Json(int value);                       // NUMBER
 87 |     Json(bool value);                      // BOOL
 88 |     Json(const std::string &value);        // STRING
 89 |     Json(std::string &&value);             // STRING
 90 |     Json(const char * value);              // STRING
 91 |     Json(const array &values);             // ARRAY
 92 |     Json(array &&values);                  // ARRAY
 93 |     Json(const object &values);            // OBJECT
 94 |     Json(object &&values);                 // OBJECT
 95 | 
 96 |     // Implicit constructor: anything with a to_json() function.
 97 |     template <class T, class = decltype(&T::to_json)>
 98 |     Json(const T & t) : Json(t.to_json()) {}
 99 | 
100 |     // Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
101 |     template <class M, typename std::enable_if<
102 |         std::is_constructible<std::string, typename M::key_type>::value
103 |         && std::is_constructible<Json, typename M::mapped_type>::value,
104 |             int>::type = 0>
105 |     Json(const M & m) : Json(object(m.begin(), m.end())) {}
106 | 
107 |     // Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
108 |     template <class V, typename std::enable_if<
109 |         std::is_constructible<Json, typename V::value_type>::value,
110 |             int>::type = 0>
111 |     Json(const V & v) : Json(array(v.begin(), v.end())) {}
112 | 
113 |     // This prevents Json(some_pointer) from accidentally producing a bool. Use
114 |     // Json(bool(some_pointer)) if that behavior is desired.
115 |     Json(void *) = delete;
116 | 
117 |     // Accessors
118 |     Type type() const;
119 | 
120 |     bool is_null()   const { return type() == NUL; }
121 |     bool is_number() const { return type() == NUMBER; }
122 |     bool is_bool()   const { return type() == BOOL; }
123 |     bool is_string() const { return type() == STRING; }
124 |     bool is_array()  const { return type() == ARRAY; }
125 |     bool is_object() const { return type() == OBJECT; }
126 | 
127 |     // Return the enclosed value if this is a number, 0 otherwise. Note that json11 does not
128 |     // distinguish between integer and non-integer numbers - number_value() and int_value()
129 |     // can both be applied to a NUMBER-typed object.
130 |     double number_value() const;
131 |     int int_value() const;
132 | 
133 |     // Return the enclosed value if this is a boolean, false otherwise.
134 |     bool bool_value() const;
135 |     // Return the enclosed string if this is a string, "" otherwise.
136 |     const std::string &string_value() const;
137 |     // Return the enclosed std::vector if this is an array, or an empty vector otherwise.
138 |     const array &array_items() const;
139 |     // Return the enclosed std::map if this is an object, or an empty map otherwise.
140 |     const object &object_items() const;
141 | 
142 |     // Return a reference to arr[i] if this is an array, Json() otherwise.
143 |     const Json & operator[](size_t i) const;
144 |     // Return a reference to obj[key] if this is an object, Json() otherwise.
145 |     const Json & operator[](const std::string &key) const;
146 | 
147 |     // Serialize.
148 |     void dump(std::string &out) const;
149 |     std::string dump() const {
150 |         std::string out;
151 |         dump(out);
152 |         return out;
153 |     }
154 | 
155 |     // Parse. If parse fails, return Json() and assign an error message to err.
156 |     static Json parse(const std::string & in, std::string & err);
157 |     static Json parse(const char * in, std::string & err) {
158 |         if (in) {
159 |             return parse(std::string(in), err);
160 |         } else {
161 |             err = "null input";
162 |             return nullptr;
163 |         }
164 |     }
165 |     // Parse multiple objects, concatenated or separated by whitespace
166 |     static std::vector<Json> parse_multi(const std::string & in, std::string & err);
167 | 
168 |     bool operator== (const Json &rhs) const;
169 |     bool operator<  (const Json &rhs) const;
170 |     bool operator!= (const Json &rhs) const { return !(*this == rhs); }
171 |     bool operator<= (const Json &rhs) const { return !(rhs < *this); }
172 |     bool operator>  (const Json &rhs) const { return  (rhs < *this); }
173 |     bool operator>= (const Json &rhs) const { return !(*this < rhs); }
174 | 
175 |     /* has_shape(types, err)
176 |      *
177 |      * Return true if this is a JSON object and, for each item in types, has a field of
178 |      * the given type. If not, return false and set err to a descriptive message.
179 |      */
180 |     typedef std::initializer_list<std::pair<std::string, Type>> shape;
181 |     bool has_shape(const shape & types, std::string & err) const;
182 | 
183 | private:
184 |     std::shared_ptr<JsonValue> m_ptr;
185 | };
186 | 
187 | // Internal class hierarchy - JsonValue objects are not exposed to users of this API.
188 | class JsonValue {
189 | protected:
190 |     friend class Json;
191 |     friend class JsonInt;
192 |     friend class JsonDouble;
193 |     virtual Json::Type type() const = 0;
194 |     virtual bool equals(const JsonValue * other) const = 0;
195 |     virtual bool less(const JsonValue * other) const = 0;
196 |     virtual void dump(std::string &out) const = 0;
197 |     virtual double number_value() const;
198 |     virtual int int_value() const;
199 |     virtual bool bool_value() const;
200 |     virtual const std::string &string_value() const;
201 |     virtual const Json::array &array_items() const;
202 |     virtual const Json &operator[](size_t i) const;
203 |     virtual const Json::object &object_items() const;
204 |     virtual const Json &operator[](const std::string &key) const;
205 |     virtual ~JsonValue() {}
206 | };
207 | 
208 | } // namespace json11


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | RedZone
  2 | =======
  3 | 
  4 | RedZone is a lightweight C++ template engine with Jinja2-like syntax support.
  5 | Inspired by [microtemplates](https://github.com/alexmic/microtemplates).
  6 | This is the starting point for other languanges extensions (e.g. Python).
  7 | Data exchange is provided via JSON protocol.
  8 | 
  9 | ## Build
 10 | 
 11 | To build RedZone library you should have installed GCC 4.9 as well as CMake tool.
 12 | Execute this shell script:
 13 | ``` sh
 14 | $ git clone https://github.com/jcfromsiberia/RedZone && cd RedZone && mkdir build && cd build && cmake .. && make
 15 | ```
 16 | 
 17 | ### Building Python extension
 18 | You'll need the same tools with Python dev package and Cython.
 19 | Use `-DBUILD_LANG_EXTENSION=python` flag for cmake command:
 20 | ``` sh
 21 | $ cmake -DBUILD_LANG_EXTENSION=python .. && make
 22 | ```
 23 | You'll find built RedZone.so python module in the build dir.
 24 | 
 25 | ## How to use?
 26 | 
 27 | There are equivalent examples for C++ and Python.
 28 | - [main.cpp](main.cpp)
 29 | - [test.py](cython/test.py)
 30 | 
 31 | Link RedZone library to your application or library and use these following classes inside:
 32 | 
 33 | #### RedZone::Writer
 34 | This is an abstract class for output. It has only two pure virtual methods
 35 | - void write( std::string const & data )
 36 | - void flush()
 37 | 
 38 | There are obly two classes which implement this abstract class:
 39 | ##### RedZone::FileWriter
 40 | Writes string data to file on disk. Constructor accepts a path to output file.
 41 | 
 42 | ``` cpp
 43 | RedZone::FileWriter writer( "/tmp/out.html" );
 44 | ```
 45 | 
 46 | ##### RedZone::StringWriter
 47 | Writes string data to in-memory string. Constructor accepts a reference to certain string.
 48 | ``` cpp
 49 | std::string out;
 50 | RedZone::FileWriter writer( out );
 51 | ```
 52 | 
 53 | 
 54 | #### RedZone::Template and its derived ones
 55 | There is only one working class `RedZone::FileTemplate` to load a template from filesystem by path for the time being.
 56 | ``` cpp
 57 | RedZone::FileTemplate tpl( "/tmp/test.tpl" );
 58 | ```
 59 | This code creates reads file contents from the given path (e.g. `/tmp/test.tpl`), parses it and then creates a new `RedZone::Template` instance.
 60 | 
 61 | #### json11::Json
 62 | RedZone uses JSON protocol for storing the rendering context. To implement JSON protocol, I have used [json11](https://github.com/dropbox/json11).
 63 | ``` cpp
 64 | json11::Json json( json11::Json::parse( R"(
 65 |       {                                               
 66 |          "items": [                                   
 67 |            { "text": "Hello World!", "active": true },
 68 |            { "text": "Foo", "active": true },         
 69 |            { "text": "Bar", "active": false }         
 70 |          ],
 71 |          "numbers": {
 72 |             "first": 5,
 73 |             "second": 11,
 74 |             "third": true
 75 |          }  
 76 |       }                                               
 77 |        )", err ) );
 78 | ```
 79 | 
 80 | #### RedZone::Context
 81 | Rendering context accepts json object-type instances only. You can not pass arrays or something else.
 82 | `RedZone::Template` classes have `render` method to render the template with user context into a `stream` represented as pointer to `Writer` isntance.
 83 | ``` cpp
 84 | RedZone::Context context( json ); 
 85 | tpl.renderToStream( &writer, &context);
 86 | context.setJson( anotherJson );
 87 | ```
 88 | 
 89 | Also they have `render` method, which returns complete rendered output. It uses `StringWriter` inside.
 90 | ``` cpp
 91 | std::string rendered = tpl.render( &context );
 92 | ```
 93 | 
 94 | RedZone supports a primitive code evaluation support. It supports main expression operations like:
 95 | 
 96 | 1. math expressions;
 97 | 2. function calls;
 98 | 3. string operations;
 99 | 4. comparison operations.
100 | 
101 | You can use them in variable blocks; as bool condition in 'if' block; as container expression in for block.
102 | 
103 | So, having this markup in `/tmp/test.tpl`:
104 | ```
105 | {% for item in items %}
106 |     {% if item.active && length(item.text) == 3 %}
107 | 	<div class="active">{{ item.text }}</div>
108 |     {% else  %}
109 | 	<div class="inactive">{{ item.text }}</div>
110 |     {% endif  %}
111 | {% endfor %}
112 | 
113 | // Testing expression parser
114 | {{ "f" * 8 + "u" * 8 + "~" }} should be ffffffffuuuuuuuu~
115 | {{upper("f"*8+"u"*8+"~")}} should be FFFFFFFFUUUUUUUU~
116 | {{ sin( 0 )}} should be 0
117 | {{ cos( 0 ) }} should be 1
118 | {{ length( [] ) }} should be 0
119 | {{ length( [ 2, 4, { "s": 55 } ] ) }} should be 3
120 | {{ length( { "key1": "value1", "key2": "value2" } ) }} should be 2
121 | {{ 16 / 4 }} should be 4
122 | {{ get( { "key1": "value1", "key2": "value2" }, "key2" ) }} should be value2
123 | {{ get( numbers, "first" ) }} should be 5
124 | {{ get( numbers, "second" ) }} should be 11
125 | {{ get( numbers, "third" ) }} should be true
126 | {{ get( numbers, "foo" ) }} should be null
127 | {{ ( 2 + 2 ) * (2 + 2) }} should be 16
128 | 
129 | {% cache 5000 "TestCache" items %}{{ random(20, 100500) }}{% endcache %} should be {% cache 5000 "TestCache" items %}{{ random(20, 100500) }}{% endcache %} cached
130 | 
131 | ```
132 | and the context which is represented above , we will get this output:
133 | ```
134 | 
135 |     
136 |         <div class="inactive">Hello World!</div>
137 |     
138 | 
139 |     
140 |         <div class="active">Foo</div>
141 |     
142 | 
143 |     
144 |         <div class="inactive">Bar</div>
145 |     
146 | 
147 | 
148 | // Testing expression parser
149 | ffffffffuuuuuuuu~ should be ffffffffuuuuuuuu~
150 | FFFFFFFFUUUUUUUU~ should be FFFFFFFFUUUUUUUU~
151 | 0 should be 0
152 | 1 should be 1
153 | 0 should be 0
154 | 3 should be 3
155 | 2 should be 2
156 | 4 should be 4
157 | value2 should be value2
158 | 5 should be 5
159 | 11 should be 11
160 | true should be true
161 | null should be null
162 | 16 should be 16
163 | 
164 | 95199 should be 95199 cached
165 | ```
166 | 
167 | ## Detailed description
168 | ### Functions
169 | | Function name | Arguments  | Return value |
170 | | :-----------: | :--------- | :----------- |
171 | | sin           | `val` numeric | (numeric) sine of `val` radians |
172 | | cos           | `val` numeric | (numeric) cosine of `val` radians |
173 | | length        | `val` string or array or object | (numeric) length value of `val` Json object |
174 | | not           | `val` bool | (bool) not `val` |
175 | | get           | `val` string or array or object<br/>`key` string or numeric | (any value or null) child item of `val` by `key` |
176 | | lower         | `val` string | (string) lowered `val` |
177 | | upper         | `val` string | (string) uppered `val` |
178 | | random        | `a`   numeric<br/>`b` numeric | (numeric) random number value in range [a, b] |
179 | 
180 | ### Binary operators
181 | | Operator | Left value | Right value | Return value |
182 | | :------: | :--------- | :---------- | :----------- |
183 | | +        | `lhs` numeric | `rhs` numeric | (numeric) addition of `lhs` and `rhs` |
184 | | +        | `lhs` string | `rhs` string | (string) concatenated string of `lhs` and `rhs` |
185 | | -        | `lhs` numeric | `rhs` numeric | (numeric) subtraction of `rhs` from `lhs` |
186 | | *        | `lhs` numeric | `rhs` numeric | (numeric) multiplication of `lhs` and `rhs` |
187 | | *        | `lhs` string | `rhs` numeric | (string) `lhs` string repeated `rhs` times |
188 | | /        | `lhs` numeric | `rhs` numeric | (numeric) division of `lhs` by `rhs` |
189 | | >        | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` > `rhs`. _Calls json11::Json approperiate operator_ |
190 | | <        | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` < `rhs`. _Calls json11::Json approperiate operator_ |
191 | | ==       | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` == `rhs`. _Calls json11::Json approperiate operator_ |
192 | | !=       | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` != `rhs`. _Calls json11::Json approperiate operator_ |
193 | | >=       | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` >= `rhs`. _Calls json11::Json approperiate operator_ |
194 | | <=       | `lhs` any object | `rhs` any object | (bool) comparison of `lhs` <= `rhs`. _Calls json11::Json approperiate operator_ |
195 | | &&       | `lhs` any object | `rhs` any object | (bool) logical AND of `lhs` and `rhs` |
196 | | &#124;&#124; | `lhs` any object | `rhs` any object | (bool) logical OR of `lhs` and `rhs` |
197 | 
198 | All operators are being executed in this order:
199 | 
200 | 1. *, /
201 | 2. +, -
202 | 3. >, <, ==, !=, <=, >=
203 | 4. &&, ||
204 | 
205 | # In Python
206 | Having built RedZone python module, you can use the above classes in your own Python scripts, excepting there is no Json class -- Python dict replaces it completely.
207 | 
208 | ```python
209 | from RedZone import *
210 | 
211 | context = Context({                                               
212 | "items": [                                   
213 |       { "text": "Hello World!", "active": True },
214 |       { "text": "Foo", "active": True },         
215 |       { "text": "Bar", "active": False }         
216 | ],
217 | "numbers": {
218 |       "first": 5,
219 |       "second": 11,
220 |       "third": True
221 | }
222 | })
223 | tpl = FileTemplate('test.tpl')
224 | 
225 | print tpl.render(context)
226 | ```
227 | You get the same output.
228 | 
229 | # In plans
230 | - ~~extend template syntax with template inheritance~~ done
231 | - ~~make Cython extension to use RedZone from Python~~ done
232 | - add install/setup scripts
233 | - add an ability to add custom functions in Python
234 | - add an ability to add custom tags in Python
235 | 


--------------------------------------------------------------------------------
/libRedZone/src/Parser/ExpressionParser.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * ExpressionParser.cpp
  3 |  *
  4 |  *      Author: jc
  5 |  */
  6 | #include "ExpressionParser.h"
  7 | 
  8 | #include <algorithm>
  9 | #include <math.h>
 10 | #include <regex>
 11 | #include <set>
 12 | #include <stack>
 13 | #include <vector>
 14 | 
 15 | #include <Common.h>
 16 | #include <Context/Context.h>
 17 | #include <Exception/ExpressionException.h>
 18 | #include <Exception/TemplateContextError.h>
 19 | 
 20 | #define MIN_PRIORITY 0
 21 | #define MAX_PRIORITY 3
 22 | #define ARGS_SIZE_CHECK(SIZE) if( args.size() != SIZE ) { \
 23 |    throw Exception( "Got " + to_string( args.size() ) + \
 24 |                     " arguments, expected " + to_string( SIZE ) ); \
 25 |    }
 26 | 
 27 | using namespace json11;
 28 | 
 29 | using namespace std;
 30 | 
 31 | namespace RedZone
 32 | {
 33 | 
 34 | ExpressionParser::ExpressionParser( Context const * context )
 35 |    : m_context( context )
 36 | {
 37 |    auto binaryOperators = m_context->binaryOperators();
 38 |    for( auto i = binaryOperators.begin(); i != binaryOperators.end(); ++i ) {
 39 |       string opString = get< 0 >( *i );
 40 |       copy( opString.begin(), opString.end(), inserter( m_binaryOperatorChars, m_binaryOperatorChars.begin() ) );
 41 |    }
 42 | }
 43 | 
 44 | Json ExpressionParser::parse( string expression ) const {
 45 |    {
 46 |       struct ValidatorData
 47 |       {
 48 |          string errorMessage;
 49 |          char open;
 50 |          char close;
 51 |       };
 52 |       // validating
 53 |       static vector< ValidatorData > const validationData {
 54 |          ValidatorData{ "Parentheses mismatch", '(', ')' },
 55 |          ValidatorData{ "Square brackets mismatch", '[', ']' },
 56 |          ValidatorData{ "Braces mismatch", '{', '}' },
 57 |       };
 58 |       stack< char > scope;
 59 |       bool betweenQuotes = false;
 60 |       string errorMessage;
 61 |       for( auto chr: expression ) {
 62 |          if( chr == '\"' ) {
 63 |             betweenQuotes = !betweenQuotes;
 64 |             continue;
 65 |          }
 66 | 
 67 |          if( betweenQuotes ) {
 68 |             continue;
 69 |          }
 70 | 
 71 |          auto matchingValidator = find_if( begin( validationData ), end( validationData ), 
 72 |             [ chr ]( auto && data ) {
 73 |             return data.open == chr || data.close == chr;
 74 |             } );
 75 | 
 76 |          if( matchingValidator != validationData.end() ) {
 77 |             if( chr == matchingValidator->open ) {
 78 |                scope.push( chr );
 79 |                errorMessage = matchingValidator->errorMessage;
 80 |                continue;
 81 |             }
 82 |             // chr == matchingValidator->close
 83 |             // TODO add assert!
 84 |             if( scope.top() == matchingValidator->open ) {
 85 |                scope.pop();
 86 |             }
 87 |          }
 88 |       }
 89 |       if( betweenQuotes ) {
 90 |          throw ExpressionException( expression, "Quotes mismatch" );
 91 |       }
 92 |       if( !scope.empty() ) {
 93 |          throw ExpressionException( expression, errorMessage );
 94 |       }
 95 |    }
 96 | 
 97 |    Json result;
 98 |    try {
 99 |       result = parseRecursive( expression );
100 |    }
101 |    catch( Exception const & ex ) {
102 |       throw ExpressionException( expression, string( " occurred an exception " ) + ex.what() );
103 |    }
104 |    return result;
105 | }
106 | 
107 | Json ExpressionParser::parseRecursive( string expression ) const {
108 |    string err;
109 | 
110 |    // trying to convert the expression to json
111 |    Json result = Json::parse( expression, err );
112 |    if( !err.length() ) {
113 |       return result;
114 |    }
115 | 
116 |    trimString( expression );
117 | 
118 |    // perhaps that's a variable
119 |    static regex const variableRegex( R"(^[a-zA-Z][a-zA-Z0-9\.]*$)" );
120 |    smatch match;
121 |    if( regex_match( expression, match, variableRegex ) ) {
122 |       try {
123 |          result = m_context->resolve( expression );
124 |          return result;
125 |       }
126 |       catch ( TemplateContextError const & ) {
127 |          // FFFFUUUUU~!
128 |       }
129 |    }
130 | 
131 |    // ok... then that's a complex expression, have to parse it... damn! I hate this
132 |    if( expression.front() == '(' && expression.back() == ')' ) {
133 |       // Ok... we might omit parentheses around this expression
134 |       // but something like "(1 + 2) + (3 + 4)" breaks everything!
135 |       // Checking for this sh#t
136 |       bool skip = false;
137 |       int pcount = 0;
138 |       for( auto i = expression.begin(); i != expression.end() ; ++i ) {
139 |          if( *i == '(' ) {
140 |             pcount++;
141 |          } else if ( *i == ')' ) {
142 |             pcount--;
143 |          }
144 |          if( !pcount && i + 1 != expression.end() ) {
145 |             skip = true;
146 |             break;
147 |          }
148 |       }
149 |       if( !skip ) {
150 |          return parseRecursive( expression.substr( 1, expression.length() - 2 ) );
151 |       }
152 |    }
153 | 
154 |    // if the expression is a function call
155 | 
156 |    Context::Functions const & functions = m_context->functions();
157 |    static regex const funcRegex( R"(^(\w+)\s*\((.+)\)$)" );
158 |    smatch funcMatch;
159 |    if( regex_match( expression, funcMatch, funcRegex ) ) {
160 |       string funcName = funcMatch[ 1 ];
161 |       Context::Functions::const_iterator foundFunc;
162 |       if( ( foundFunc = functions.find( funcName ) ) == functions.end() ) {
163 |          throw ExpressionException( expression, "No such function: " + funcName );
164 |       }
165 |       string argsString = funcMatch[ 2 ];
166 |       vector< Json > args;
167 |       int pcount = 0, qbcount = 0, bcount = 0;
168 |       bool inQuotes = false;
169 |       decltype( argsString )::const_iterator start = argsString.begin(), current = argsString.begin();
170 |       for( ; current != argsString.end(); ++current ) {
171 |          if( *current == '"' ) {
172 |             inQuotes = !inQuotes;
173 |          }
174 |          if( inQuotes ) {
175 |             continue;
176 |          }
177 |          if( *current == '(' ) {
178 |             pcount++;
179 |          }
180 |          else if( *current == ')' ) {
181 |             pcount--;
182 |          }
183 |          if( *current == '[' ) {
184 |             qbcount++;
185 |          }
186 |          else if( *current == ']' ) {
187 |             qbcount--;
188 |          }
189 |          if( *current == '{' ) {
190 |             bcount++;
191 |          }
192 |          else if( *current == '}' ) {
193 |             bcount--;
194 |          }
195 |          // monkeycoding... hate this!
196 |          bool isInBrackets = pcount != 0 || qbcount != 0 || bcount != 0;
197 |          bool nextIsEnd = current + 1 == argsString.end();
198 |          if( !isInBrackets && ( *current == ',' || nextIsEnd ) ) {
199 |             string argExpr;
200 |             copy( start, current + ( nextIsEnd ? 1 : 0 ), back_inserter( argExpr ) );
201 |             args.push_back( parseRecursive( argExpr ) );
202 |             start = current + 1; // FIXME: oops, it's dangerous
203 |          }
204 |       }
205 |       try {
206 |          result = foundFunc->second( args );
207 |       }
208 |       catch( Exception const & ex ) {
209 |          throw ExpressionException( expression, foundFunc->first + " raised exception: " + ex.what() );
210 |       }
211 |       return result;
212 |    }
213 | 
214 |    // it the expression is an expression exactly...
215 |    Context::BinaryOperators const & binaryOperators = m_context->binaryOperators();
216 |    for( int priority = MIN_PRIORITY; priority <= MAX_PRIORITY; ++priority ) {
217 |       int len = expression.length(), i = 0, pcount = 0;
218 |       bool inQuotes = false;
219 |       string lhs, rhs;
220 |       i = len - 1;
221 |       while( i >= 0 ) {
222 |          if( expression[ i ] == '"' ) {
223 |             inQuotes = !inQuotes;
224 |          }
225 |          if( inQuotes ) {
226 |             i--;
227 |             continue;
228 |          }
229 |          if( expression[ i ] == ')' ) {
230 |             pcount++;
231 |          }
232 |          else if( expression[ i ] == '(' ) {
233 |             pcount--;
234 |          }
235 |          auto finder = [ & ]( Context::BinaryOperators::value_type const & opData ) {
236 |             if( priority != get< 1 >( opData ) )
237 |                return false;
238 |             string op = get< 0 >( opData );
239 |             string possibleOp;
240 |             int sensor = i;
241 |             for( ;
242 |                sensor < expression.length() && m_binaryOperatorChars.find( expression[ sensor ] ) != m_binaryOperatorChars.end();
243 |                ++sensor ) {
244 |                possibleOp.push_back( expression[ sensor ] );
245 |             }
246 |             return op == possibleOp;
247 |          };
248 |          Context::BinaryOperators::const_iterator opIter;
249 |          if( !pcount && m_binaryOperatorChars.find( expression[ i ] ) != m_binaryOperatorChars.end() &&
250 |             ( opIter = find_if( binaryOperators.begin(), binaryOperators.end(), finder ) ) != binaryOperators.end() ) {
251 |             rhs = expression.substr( i + get< 0 >( *opIter ).length() );
252 |             lhs = expression.substr( 0, i );
253 |             try {
254 |                result = get< 2 >( *opIter )( parseRecursive( lhs ), parseRecursive( rhs ) );
255 |             }
256 |             catch( Exception const & ex ) {
257 |                throw ExpressionException( expression, "operator " + get< 0 >( *opIter ) + " raised exception: " + ex.what() );
258 |             }
259 |             return result;
260 |          }
261 |          i--;
262 |       }
263 |    }
264 | 
265 |    // else
266 |    throw ExpressionException( expression, "Wrong syntax or undefined variable" );
267 | }
268 | 
269 | ExpressionParser::~ExpressionParser()
270 | {
271 | }
272 | 
273 | } /* namespace RedZone */
274 | 


--------------------------------------------------------------------------------
/cmake/UseCython.cmake:
--------------------------------------------------------------------------------
  1 | # Define a function to create Cython modules.
  2 | #
  3 | # For more information on the Cython project, see http://cython.org/.
  4 | # "Cython is a language that makes writing C extensions for the Python language
  5 | # as easy as Python itself."
  6 | #
  7 | # This file defines a CMake function to build a Cython Python module.
  8 | # To use it, first include this file.
  9 | #
 10 | #   include( UseCython )
 11 | #
 12 | # Then call cython_add_module to create a module.
 13 | #
 14 | #   cython_add_module( <module_name> <src1> <src2> ... <srcN> )
 15 | #
 16 | # To create a standalone executable, the function
 17 | #
 18 | #   cython_add_standalone_executable( <executable_name> [MAIN_MODULE src1] <src1> <src2> ... <srcN> )
 19 | #
 20 | # To avoid dependence on Python, set the PYTHON_LIBRARY cache variable to point
 21 | # to a static library.  If a MAIN_MODULE source is specified, 
 22 | # the "if __name__ == '__main__':" from that module is used as the C main() method
 23 | # for the executable.  If MAIN_MODULE, the source with the same basename as
 24 | # <executable_name> is assumed to be the MAIN_MODULE.
 25 | #
 26 | # Where <module_name> is the name of the resulting Python module and
 27 | # <src1> <src2> ... are source files to be compiled into the module, e.g. *.pyx,
 28 | # *.py, *.c, *.cxx, etc.  A CMake target is created with name <module_name>.  This can
 29 | # be used for target_link_libraries(), etc.
 30 | #
 31 | # The sample paths set with the CMake include_directories() command will be used
 32 | # for include directories to search for *.pxd when running the Cython complire.
 33 | #
 34 | # Cache variables that effect the behavior include:
 35 | #
 36 | #  CYTHON_ANNOTATE
 37 | #  CYTHON_NO_DOCSTRINGS
 38 | #  CYTHON_FLAGS
 39 | #
 40 | # Source file properties that effect the build process are
 41 | #
 42 | #  CYTHON_IS_CXX
 43 | #
 44 | # If this is set of a *.pyx file with CMake set_source_files_properties()
 45 | # command, the file will be compiled as a C++ file.
 46 | #
 47 | # See also FindCython.cmake
 48 | 
 49 | #=============================================================================
 50 | # Copyright 2011 Kitware, Inc.
 51 | #
 52 | # Licensed under the Apache License, Version 2.0 (the "License");
 53 | # you may not use this file except in compliance with the License.
 54 | # You may obtain a copy of the License at
 55 | #
 56 | #     http://www.apache.org/licenses/LICENSE-2.0
 57 | #
 58 | # Unless required by applicable law or agreed to in writing, software
 59 | # distributed under the License is distributed on an "AS IS" BASIS,
 60 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 61 | # See the License for the specific language governing permissions and
 62 | # limitations under the License.
 63 | #=============================================================================
 64 | 
 65 | # Configuration options.
 66 | set( CYTHON_ANNOTATE OFF
 67 |   CACHE BOOL "Create an annotated .html file when compiling *.pyx." )
 68 | set( CYTHON_NO_DOCSTRINGS OFF
 69 |   CACHE BOOL "Strip docstrings from the compiled module." )
 70 | set( CYTHON_FLAGS "" CACHE STRING
 71 |   "Extra flags to the cython compiler." )
 72 | mark_as_advanced( CYTHON_ANNOTATE CYTHON_NO_DOCSTRINGS CYTHON_FLAGS )
 73 | 
 74 | find_package( Cython REQUIRED )
 75 | find_package( PythonLibs REQUIRED )
 76 | 
 77 | set( CYTHON_CXX_EXTENSION "cxx" )
 78 | set( CYTHON_C_EXTENSION "c" )
 79 | 
 80 | # Create a *.c or *.cxx file from a *.pyx file.
 81 | # Input the generated file basename.  The generate file will put into the variable
 82 | # placed in the "generated_file" argument. Finally all the *.py and *.pyx files.
 83 | function( compile_pyx _name generated_file )
 84 |   # Default to assuming all files are C.
 85 |   set( cxx_arg "" )
 86 |   set( extension ${CYTHON_C_EXTENSION} )
 87 |   set( pyx_lang "C" )
 88 |   set( comment "Compiling Cython C source for ${_name}..." )
 89 | 
 90 |   set( cython_include_directories "" )
 91 |   set( pxd_dependencies "" )
 92 |   set( c_header_dependencies "" )
 93 |   set( pyx_locations "" )
 94 |   
 95 | 
 96 |   foreach( pyx_file ${ARGN} )
 97 |   
 98 |     get_filename_component( pyx_file_basename "${pyx_file}" NAME_WE )
 99 | 
100 |     # Determine if it is a C or C++ file.
101 |     get_source_file_property( property_is_cxx ${pyx_file} CYTHON_IS_CXX )
102 |     if( ${property_is_cxx} MATCHES "TRUE" )
103 |       set( cxx_arg "--cplus" )
104 |       set( extension ${CYTHON_CXX_EXTENSION} )
105 |       set( pyx_lang "CXX" )
106 |       set( comment "Compiling Cython CXX source for ${_name}..." )
107 |     endif()
108 | 
109 |     # Get the include directories.
110 |     get_source_file_property( pyx_location ${pyx_file} LOCATION )
111 |     get_filename_component( pyx_path ${pyx_location} PATH )
112 |     #get_directory_property( cmake_include_directories DIRECTORY ${pyx_path} INCLUDE_DIRECTORIES )
113 |     list( APPEND cython_include_directories ${cmake_include_directories} )
114 |     list( APPEND pyx_locations "${pyx_location}" )
115 | 
116 |     # Determine dependencies.
117 |     # Add the pxd file will the same name as the given pyx file.
118 |     unset( corresponding_pxd_file CACHE )
119 |     find_file( corresponding_pxd_file ${pyx_file_basename}.pxd
120 |       PATHS "${pyx_path}" ${cmake_include_directories} 
121 |       NO_DEFAULT_PATH )
122 |     if( corresponding_pxd_file )
123 |       list( APPEND pxd_dependencies "${corresponding_pxd_file}" )
124 |     endif()
125 | 
126 |     # pxd files to check for additional dependencies.
127 |     set( pxds_to_check "${pyx_file}" "${pxd_dependencies}" )
128 |     set( pxds_checked "" )
129 |     set( number_pxds_to_check 1 )
130 |     while( ${number_pxds_to_check} GREATER 0 )
131 |       foreach( pxd ${pxds_to_check} )
132 |         list( APPEND pxds_checked "${pxd}" )
133 |         list( REMOVE_ITEM pxds_to_check "${pxd}" )
134 | 
135 |         # check for C header dependencies
136 |         file( STRINGS "${pxd}" extern_from_statements
137 |           REGEX "cdef[ ]+extern[ ]+from.*$" )
138 |         foreach( statement ${extern_from_statements} )
139 |           # Had trouble getting the quote in the regex
140 |           string( REGEX REPLACE "cdef[ ]+extern[ ]+from[ ]+[\"]([^\"]+)[\"].*" "\\1" header "${statement}" )
141 |           unset( header_location CACHE )
142 |           find_file( header_location ${header} PATHS ${cmake_include_directories} )
143 |           if( header_location )
144 |             list( FIND c_header_dependencies "${header_location}" header_idx )
145 |             if( ${header_idx} LESS 0 )
146 |               list( APPEND c_header_dependencies "${header_location}" )
147 |             endif()
148 |           endif()
149 |         endforeach()
150 | 
151 |         # check for pxd dependencies
152 | 
153 |         # Look for cimport statements.
154 |         set( module_dependencies "" )
155 |         file( STRINGS "${pxd}" cimport_statements REGEX cimport )
156 |         foreach( statement ${cimport_statements} )
157 |           if( ${statement} MATCHES from )
158 |             string( REGEX REPLACE "from[ ]+([^ ]+).*" "\\1" module "${statement}" )
159 |           else()
160 |             string( REGEX REPLACE "cimport[ ]+([^ ]+).*" "\\1" module "${statement}" )
161 |           endif()
162 |           list( APPEND module_dependencies ${module} )
163 |         endforeach()
164 |         list( REMOVE_DUPLICATES module_dependencies )
165 |         # Add the module to the files to check, if appropriate.
166 |         foreach( module ${module_dependencies} )
167 |           unset( pxd_location CACHE )
168 |           find_file( pxd_location ${module}.pxd
169 |             PATHS "${pyx_path}" ${cmake_include_directories} NO_DEFAULT_PATH )
170 |           if( pxd_location )
171 |             list( FIND pxds_checked ${pxd_location} pxd_idx )
172 |             if( ${pxd_idx} LESS 0 )
173 |               list( FIND pxds_to_check ${pxd_location} pxd_idx )
174 |               if( ${pxd_idx} LESS 0 )
175 |                 list( APPEND pxds_to_check ${pxd_location} )
176 |                 list( APPEND pxd_dependencies ${pxd_location} )
177 |               endif() # if it is not already going to be checked
178 |             endif() # if it has not already been checked
179 |           endif() # if pxd file can be found
180 |         endforeach() # for each module dependency discovered
181 |       endforeach() # for each pxd file to check
182 |       list( LENGTH pxds_to_check number_pxds_to_check )
183 |     endwhile()
184 |   endforeach() # pyx_file
185 | 
186 |   # Set additional flags.
187 |   if( CYTHON_ANNOTATE )
188 |     set( annotate_arg "--annotate" )
189 |   endif()
190 | 
191 |   if( CYTHON_NO_DOCSTRINGS )
192 |     set( no_docstrings_arg "--no-docstrings" )
193 |   endif()
194 | 
195 |   if( "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" OR
196 |         "${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" )
197 |       set( cython_debug_arg "--gdb" )
198 |   endif()
199 | 
200 |   if( "${PYTHONLIBS_VERSION_STRING}" MATCHES "^2." )
201 |     set( version_arg "-2" )
202 |   elseif( "${PYTHONLIBS_VERSION_STRING}" MATCHES "^3." )
203 |     set( version_arg "-3" )
204 |   else()
205 |     set( version_arg )
206 |   endif()
207 | 
208 |   # Include directory arguments. 
209 |   list( REMOVE_DUPLICATES cython_include_directories )
210 |   set( include_directory_arg "" )
211 |   foreach( _include_dir ${cython_include_directories} )
212 |     set( include_directory_arg ${include_directory_arg} "-I" "${_include_dir}" )
213 |   endforeach()
214 | 
215 |   # Determining generated file name.
216 |   set( _generated_file "${CMAKE_CURRENT_BINARY_DIR}/${_name}.${extension}" )
217 |   set_source_files_properties( ${_generated_file} PROPERTIES GENERATED TRUE )
218 |   set( ${generated_file} ${_generated_file} PARENT_SCOPE )
219 | 
220 |   list( REMOVE_DUPLICATES pxd_dependencies )
221 |   list( REMOVE_DUPLICATES c_header_dependencies )
222 | 
223 |   # Add the command to run the compiler.
224 |   add_custom_command( OUTPUT ${_generated_file}
225 |     COMMAND ${CYTHON_EXECUTABLE}
226 |     ARGS ${cxx_arg} ${include_directory_arg} ${version_arg}
227 |     ${annotate_arg} ${no_docstrings_arg} ${cython_debug_arg} ${CYTHON_FLAGS}
228 |     --output-file  ${_generated_file} ${pyx_locations}
229 |     DEPENDS ${pyx_locations} ${pxd_dependencies}
230 |     IMPLICIT_DEPENDS ${pyx_lang} ${c_header_dependencies}
231 |     COMMENT ${comment}
232 |     )
233 | 
234 |   # Remove their visibility to the user.
235 |   set( corresponding_pxd_file "" CACHE INTERNAL "" )
236 |   set( header_location "" CACHE INTERNAL "" )
237 |   set( pxd_location "" CACHE INTERNAL "" )
238 | endfunction()
239 | 
240 | # cython_add_module( <name> src1 src2 ... srcN )
241 | # Build the Cython Python module.
242 | function( cython_add_module _name )
243 |   set( pyx_module_sources "" )
244 |   set( other_module_sources "" )
245 |   foreach( _file ${ARGN} )
246 |     if( ${_file} MATCHES ".*\\.py[x]?$" )
247 |       list( APPEND pyx_module_sources ${_file} )
248 |     else()
249 |       list( APPEND other_module_sources ${_file} )
250 |     endif()
251 |   endforeach()
252 |   compile_pyx( ${_name} generated_file ${pyx_module_sources} )
253 |   include_directories( ${PYTHON_INCLUDE_DIRS} )
254 |   python_add_module( ${_name} ${generated_file} ${other_module_sources} )
255 |   if( APPLE )
256 |     set_target_properties( ${_name} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup" )
257 |   else()
258 |     target_link_libraries( ${_name} ${PYTHON_LIBRARIES} )
259 |   endif()
260 | endfunction()
261 | 
262 | include( CMakeParseArguments )
263 | # cython_add_standalone_executable( _name [MAIN_MODULE src3.py] src1 src2 ... srcN )
264 | # Creates a standalone executable the given sources.
265 | function( cython_add_standalone_executable _name )
266 |   set( pyx_module_sources "" )
267 |   set( other_module_sources "" )
268 |   set( main_module "" )
269 |   cmake_parse_arguments( cython_arguments "" "MAIN_MODULE" "" ${ARGN} )
270 |   include_directories( ${PYTHON_INCLUDE_DIRS} )
271 |   foreach( _file ${cython_arguments_UNPARSED_ARGUMENTS} )
272 |     if( ${_file} MATCHES ".*\\.py[x]?$" )
273 |       get_filename_component( _file_we ${_file} NAME_WE )
274 |       if( "${_file_we}" STREQUAL "${_name}" )
275 |         set( main_module "${_file}" )
276 |       elseif( NOT "${_file}" STREQUAL "${cython_arguments_MAIN_MODULE}" )
277 |         set( PYTHON_MODULE_${_file_we}_static_BUILD_SHARED OFF )
278 |         compile_pyx( "${_file_we}_static" generated_file "${_file}" )
279 |         list( APPEND pyx_module_sources "${generated_file}" )
280 |       endif()
281 |     else()
282 |       list( APPEND other_module_sources ${_file} )
283 |     endif()
284 |   endforeach()
285 | 
286 |   if( cython_arguments_MAIN_MODULE )
287 |     set( main_module ${cython_arguments_MAIN_MODULE} )
288 |   endif()
289 |   if( NOT main_module )
290 |     message( FATAL_ERROR "main module not found." )
291 |   endif()
292 |   get_filename_component( main_module_we "${main_module}" NAME_WE )
293 |   set( CYTHON_FLAGS ${CYTHON_FLAGS} --embed )
294 |   compile_pyx( "${main_module_we}_static" generated_file ${main_module} )
295 |   add_executable( ${_name} ${generated_file} ${pyx_module_sources} ${other_module_sources} )
296 |   target_link_libraries( ${_name} ${PYTHON_LIBRARIES} ${pyx_module_libs} )
297 | endfunction()


--------------------------------------------------------------------------------
/libRedZone/src/Context/Context.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Context.cpp
  3 |  *
  4 |  *  Created on: 21 ���� 2014 �.
  5 |  *      Author: jc
  6 |  */
  7 | 
  8 | #include "Context.h"
  9 | 
 10 | #include <cmath>
 11 | #include <iostream>
 12 | #include <random>
 13 | #include <regex>
 14 | 
 15 | #include <Common.h>
 16 | #include <Exception/JsonError.h>
 17 | #include <Exception/TemplateContextError.h>
 18 | 
 19 | #define ARGS_SIZE_CHECK(SIZE) if( args.size() != SIZE ) { \
 20 |    throw Exception( "Got " + std::to_string( args.size() ) + \
 21 |                     " arguments, expected " + std::to_string( SIZE ) ); \
 22 |    }
 23 | 
 24 | using namespace json11;
 25 | 
 26 | namespace RedZone {
 27 | 
 28 | Context::Context()
 29 |    : m_binaryOperations(
 30 |       {
 31 |          std::make_tuple( "+", 2, []( Json const & lhs, Json const & rhs ) -> Json {
 32 |             static std::map< std::tuple< Json::Type, Json::Type >,
 33 |                std::function< Json( Json const &, Json const & ) > > const possibleOperations {
 34 |                { std::make_tuple( Json::NUMBER, Json::NUMBER ),
 35 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 36 |                   // Yes-yes, I know about implicit constructors feature
 37 |                   // but I'd rather to call explicit instead
 38 |                   return Json( lhs.number_value() + rhs.number_value() );
 39 |                }
 40 |                },
 41 |                { std::make_tuple( Json::STRING, Json::STRING ),
 42 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 43 |                   return Json( lhs.string_value() + rhs.string_value() );
 44 |                }
 45 |                },
 46 |                { std::make_tuple( Json::NUMBER, Json::STRING ),
 47 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 48 |                   return Json( dbl2str( lhs.number_value() ) + rhs.string_value() );
 49 |                }
 50 |                },
 51 |                { std::make_tuple( Json::STRING, Json::NUMBER ),
 52 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 53 |                   return Json( lhs.string_value() + dbl2str( rhs.number_value() ) );
 54 |                }
 55 |                }
 56 |             };
 57 |             decltype( possibleOperations )::const_iterator foundOperation;
 58 |             if( ( foundOperation = possibleOperations.find(
 59 |                      std::make_tuple( lhs.type(), rhs.type() ) ) ) == possibleOperations.end() ) {
 60 |                throw Exception( "Type mismatch: can not add " + lhs.dump() + " to " + rhs.dump() );
 61 |             }
 62 |             return foundOperation->second( lhs, rhs );
 63 |          } ),
 64 | 
 65 |          std::make_tuple( "-", 2, []( Json const & lhs, Json const & rhs ) -> Json {
 66 |             static std::map< std::tuple< Json::Type, Json::Type >,
 67 |                std::function< Json( Json const &, Json const & ) > > const possibleOperations {
 68 |                { std::make_tuple( Json::NUMBER, Json::NUMBER ),
 69 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 70 |                   return Json( lhs.number_value() - rhs.number_value() );
 71 |                }
 72 |                }
 73 |             };
 74 |             decltype( possibleOperations )::const_iterator foundOperation;
 75 |             if( ( foundOperation = possibleOperations.find(
 76 |                      std::make_tuple( lhs.type(), rhs.type() ) ) ) == possibleOperations.end() ) {
 77 |                throw Exception( "Type mismatch: can not subtract " + lhs.dump() + " from " + rhs.dump() );
 78 |             }
 79 |             return foundOperation->second( lhs, rhs );
 80 |          } ),
 81 | 
 82 |          std::make_tuple( "*", 3, []( Json const & lhs, Json const & rhs ) -> Json {
 83 |             static std::map< std::tuple< Json::Type, Json::Type >,
 84 |                std::function< Json( Json const &, Json const & ) > > const possibleOperations {
 85 |                { std::make_tuple( Json::NUMBER, Json::NUMBER ),
 86 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 87 |                   return Json( lhs.number_value() * rhs.number_value() );
 88 |                }
 89 |                },
 90 |                { std::make_tuple( Json::STRING, Json::NUMBER ),
 91 |                   []( Json const & lhs, Json const & rhs ) -> Json {
 92 |                   std::string repeated;
 93 |                   if( rhs.number_value() < 0.f ) {
 94 |                      throw Exception( "String multiplier is negative" );
 95 |                   }
 96 |                   for( auto i = 0; i < rhs.number_value(); ++i ) {
 97 |                      repeated += lhs.string_value();
 98 |                   }
 99 |                   return Json( repeated );
100 |                }
101 |                },
102 |             };
103 | 
104 |             decltype( possibleOperations )::const_iterator foundOperation;
105 |             if( ( foundOperation = possibleOperations.find(
106 |                      std::make_tuple( lhs.type(), rhs.type() ) ) ) == possibleOperations.end() ) {
107 |                throw Exception( "Type mismatch: can not multiply " + lhs.dump() + " and " + rhs.dump() );
108 |             }
109 |             return foundOperation->second( lhs, rhs );
110 |          } ),
111 |          std::make_tuple( "/", 3, []( Json const & lhs, Json const & rhs ) -> Json {
112 |             static std::map< std::tuple< Json::Type, Json::Type >,
113 |                std::function< Json( Json const &, Json const & ) > > const possibleOperations {
114 |                { std::make_tuple( Json::NUMBER, Json::NUMBER ),
115 |                   []( Json const & lhs, Json const & rhs ) -> Json {
116 |                   return Json( lhs.number_value() / rhs.number_value() );
117 |                }
118 |                }
119 |             };
120 |             decltype( possibleOperations )::const_iterator foundOperation;
121 |             if( ( foundOperation = possibleOperations.find(
122 |                      std::make_tuple( lhs.type(), rhs.type() ) ) ) == possibleOperations.end() ) {
123 |                throw Exception( "Type mismatch: can not divide " + lhs.dump() + " by " + rhs.dump() );
124 |             }
125 |             return foundOperation->second( lhs, rhs );
126 |          } ),
127 |          std::make_tuple( ">", 1, []( Json const & lhs, Json const & rhs ) -> Json {
128 |             return lhs > rhs;
129 |          } ),
130 |          std::make_tuple( "<", 1, []( Json const & lhs, Json const & rhs ) -> Json {
131 |             return lhs < rhs;
132 |          } ),
133 |          std::make_tuple( "==", 1, []( Json const & lhs, Json const & rhs ) -> Json {
134 |             return lhs == rhs;
135 |          } ),
136 |          std::make_tuple( "!=", 1, []( Json const & lhs, Json const & rhs ) -> Json {
137 |             return lhs != rhs;
138 |          } ),
139 |          std::make_tuple( "<=", 1, []( Json const & lhs, Json const & rhs ) -> Json {
140 |             return lhs <= rhs;
141 |          } ),
142 |          std::make_tuple( ">=", 1, []( Json const & lhs, Json const & rhs ) -> Json {
143 |             return lhs >= rhs;
144 |          } ),
145 |          std::make_tuple( "&&", 0, []( Json const & lhs, Json const & rhs ) -> Json {
146 |             return lhs.bool_value() && rhs.bool_value();
147 |          } ),
148 |          std::make_tuple( "||", 0, []( Json const & lhs, Json const & rhs ) -> Json {
149 |             return lhs.bool_value() || rhs.bool_value();
150 |          } )
151 |          // we need more gol... operators!
152 |       } )
153 |    , m_functions(
154 |       {
155 |          { "sin", []( std::vector< Json > const & args ) -> Json {
156 |             ARGS_SIZE_CHECK( 1 );
157 |             if( !args[ 0 ].is_number() ) {
158 |                throw Exception( "Function accepts only numeric arguments" );
159 |             }
160 |             return Json( ::sin( args[ 0 ].number_value() ) );
161 |          } },
162 |          { "cos", []( std::vector< Json > const & args ) -> Json {
163 |             ARGS_SIZE_CHECK( 1 );
164 |             if( !args[ 0 ].is_number() ) {
165 |                throw Exception( "Function accepts only numeric arguments" );
166 |             }
167 |             return Json( ::cos( args[ 0 ].number_value() ) );
168 |          } },
169 |          { "length", []( std::vector< Json > const & args ) -> Json {
170 |             ARGS_SIZE_CHECK( 1 );
171 |             Json arg = args[ 0 ];
172 |             if( arg.is_array() ) {
173 |                return Json( int( arg.array_items().size() ) );
174 |             } else if( arg.is_object() ) {
175 |                return Json( int( arg.object_items().size() ) );
176 |             } else if( arg.is_string() ) {
177 |                return Json( int( arg.string_value().size() ) );
178 |             } else {
179 |                throw Exception( "Can not calculate length of non-iterable object: " + arg.dump() );
180 |             }
181 |          } },
182 |          { "not", []( std::vector< Json > const & args ) -> Json {
183 |             ARGS_SIZE_CHECK( 1 );
184 |             return Json( !args[ 0 ].bool_value() );
185 |          } },
186 |          { "get", []( std::vector< Json > const & args ) -> Json {
187 |             ARGS_SIZE_CHECK( 2 );
188 |             Json container = args[ 0 ];
189 |             Json key = args[ 1 ];
190 |             Json result;
191 |             if( container.is_array() ) {
192 |                if( !key.is_number() ) {
193 |                   throw Exception( "Key must be number, got " + key.dump() );
194 |                }
195 |                return container[ static_cast< size_t >( key.number_value() ) ];
196 |             } else if( container.is_object() ) {
197 |                if( !key.is_string() ) {
198 |                   throw Exception( "Key must be string, got " + key.dump() );
199 |                }
200 |                return container[ key.string_value() ];
201 |             } else if( container.is_string() ) {
202 |                if( !key.is_number() ) {
203 |                   throw Exception( "Key must be number, got " + key.dump() );
204 |                }
205 |                return Json(
206 |                   std::string( 1, container.string_value()[ static_cast< size_t >( key.number_value() ) ] ) );
207 |             }
208 |             throw Exception( "Can not get anything from " + container.dump() );
209 |          } },
210 |          { "lower", []( std::vector< Json > const & args ) -> Json {
211 |             ARGS_SIZE_CHECK( 1 );
212 |             if( !args[ 0 ].is_string() ) {
213 |                throw Exception( "Can not make lower non-string objects" );
214 |             }
215 |             std::string arg = args[ 0 ].string_value();
216 |             std::string result;
217 |             std::transform( arg.begin(), arg.end(), std::back_inserter( result ), ::tolower );
218 |             return Json( result );
219 |          } },
220 |          { "upper", []( std::vector< Json > const & args ) -> Json {
221 |             ARGS_SIZE_CHECK( 1 );
222 |             if( !args[ 0 ].is_string() ) {
223 |                throw Exception( "Can not make upper non-string objects" );
224 |             }
225 |             std::string arg = args[ 0 ].string_value();
226 |             std::string result;
227 |             std::transform( arg.begin(), arg.end(), std::back_inserter( result ), ::toupper );
228 |             return Json( result );
229 |          } },
230 |          { "contains", []( std::vector< Json > const & args ) -> Json {
231 |             ARGS_SIZE_CHECK( 2 );
232 |             bool result = false;
233 |             if( args[ 0 ].is_string() && args[ 1 ].is_object() ) {
234 |                if( args[ 1 ][ args[ 0 ].string_value() ].type() != Json::NUL ) {
235 |                   result = true;
236 |                }
237 |             }
238 |             else if ( args[ 0 ].is_string() && args[ 1 ].is_string() ) {
239 |                result = args[ 1 ].string_value().find( args[ 0 ].string_value() ) != std::string::npos;
240 |             }
241 |             else if ( args[ 1 ].is_array() ) {
242 |                auto arrayItems = args[ 1 ].array_items();
243 |                result = std::find( arrayItems.begin(), arrayItems.end(), args[ 0 ] ) != arrayItems.end();
244 |             }
245 |             else {
246 |                throw Exception( "Can not find appropriate signature" );
247 |             }
248 |             return Json( result );
249 |          } },
250 |          { "to_json", []( std::vector< Json > const & args ) -> Json {
251 |             ARGS_SIZE_CHECK( 1 );
252 |             return Json( args[ 0 ].dump() );
253 |          } },
254 |          { "random", []( std::vector< Json > const & args ) -> Json {
255 |             ARGS_SIZE_CHECK( 2 );
256 |             if( ! args[ 0 ].is_number() || ! args[ 1 ].is_number() ) {
257 |                throw Exception( "Function accepts only numeric arguments" );
258 |             }
259 |             int a = int( args[ 0 ].number_value() ),
260 |                 b = int( args[ 1 ].number_value() );
261 |             if( a == b )
262 |             {
263 |                return Json( a );
264 |             }
265 |             if( a > b )
266 |             {
267 |                std::swap( a, b );
268 |             }
269 |             std::random_device seed;
270 |             std::default_random_engine generator( seed() );
271 |             std::uniform_int_distribution< int > distribution( a, b );
272 |             return Json( distribution( generator ) );
273 |          } },
274 |       } ) {
275 | }
276 | 
277 | Context::Context( std::string const & json )
278 |    : Context() {
279 |    std::string err;
280 |    m_json = Json::parse( json, err );
281 |    if( err.size() ) {
282 |       throw JsonError( err );
283 |    }
284 |    if( !m_json.is_object() ) {
285 |       throw JsonError( "Context data must be presented in dictionary type." );
286 |    }
287 | }
288 | 
289 | Context::Context( json11::Json const & json )
290 |    : Context() {
291 |    m_json = json;
292 |    if( !m_json.is_object() ) {
293 |       throw JsonError( "Context data must be presented in dictionary type." );
294 |    }
295 | }
296 | 
297 | json11::Json Context::json() const {
298 |    return m_json;
299 | }
300 | 
301 | void Context::setJson( json11::Json const & json ) {
302 |    if( !m_json.is_object() ) {
303 |       throw JsonError( "Context data must be presented in dictionary type." );
304 |    }
305 |    m_json = json;
306 | }
307 | 
308 | Json Context::resolve( std::string const & name ) const {
309 |    Json result = m_json;
310 |    static const std::regex splitter( R"(\.)" );
311 |    std::sregex_token_iterator iter( name.begin(), name.end(), splitter, -1 );
312 |    static const std::sregex_token_iterator end;
313 |    for( ; iter != end; ++iter ) {
314 |       Json tmp = result[ *iter ];
315 |       if( tmp.is_null() ) {
316 |           throw TemplateContextError( name );
317 |       }
318 |       result = tmp;
319 |    }
320 |    return result;
321 | }
322 | 
323 | Context::BinaryOperators const & Context::binaryOperators() const {
324 |    return m_binaryOperations;
325 | }
326 | 
327 | Context::Functions const & Context::functions() const {
328 |    return m_functions;
329 | }
330 | 
331 | Context::~Context() {
332 | }
333 | 
334 | } /* namespace RedZone */
335 | 


--------------------------------------------------------------------------------
/libRedZone/src/Context/json11.cpp:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2013 Dropbox, Inc.
  2 |  *
  3 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  4 |  * of this software and associated documentation files (the "Software"), to deal
  5 |  * in the Software without restriction, including without limitation the rights
  6 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  7 |  * copies of the Software, and to permit persons to whom the Software is
  8 |  * furnished to do so, subject to the following conditions:
  9 |  *
 10 |  * The above copyright notice and this permission notice shall be included in
 11 |  * all copies or substantial portions of the Software.
 12 |  *
 13 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 14 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 15 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 16 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 17 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 18 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 19 |  * THE SOFTWARE.
 20 |  */
 21 | 
 22 | #include "json11.hpp"
 23 | #include <cassert>
 24 | #include <cstdlib>
 25 | #include <cstdio>
 26 | #include <limits>
 27 | 
 28 | #ifdef _MSC_VER
 29 | #define snprintf _snprintf
 30 | #endif
 31 | 
 32 | namespace json11 {
 33 | 
 34 | static const int max_depth = 200;
 35 | 
 36 | using std::string;
 37 | using std::vector;
 38 | using std::map;
 39 | using std::make_shared;
 40 | using std::initializer_list;
 41 | using std::move;
 42 | 
 43 | /* * * * * * * * * * * * * * * * * * * *
 44 |  * Serialization
 45 |  */
 46 | 
 47 | static void dump(std::nullptr_t, string &out) {
 48 |     out += "null";
 49 | }
 50 | 
 51 | static void dump(double value, string &out) {
 52 |     char buf[32];
 53 |     snprintf(buf, sizeof buf, "%.17g", value);
 54 |     out += buf;
 55 | }
 56 | 
 57 | static void dump(int value, string &out) {
 58 |     char buf[32];
 59 |     snprintf(buf, sizeof buf, "%d", value);
 60 |     out += buf;
 61 | }
 62 | 
 63 | static void dump(bool value, string &out) {
 64 |     out += value ? "true" : "false";
 65 | }
 66 | 
 67 | static void dump(const string &value, string &out) {
 68 |     out += '"';
 69 |     for (size_t i = 0; i < value.length(); i++) {
 70 |         const char ch = value[i];
 71 |         if (ch == '\\') {
 72 |             out += "\\\\";
 73 |         } else if (ch == '"') {
 74 |             out += "\\\"";
 75 |         } else if (ch == '\b') {
 76 |             out += "\\b";
 77 |         } else if (ch == '\f') {
 78 |             out += "\\f";
 79 |         } else if (ch == '\n') {
 80 |             out += "\\n";
 81 |         } else if (ch == '\r') {
 82 |             out += "\\r";
 83 |         } else if (ch == '\t') {
 84 |             out += "\\t";
 85 |         } else if ((uint8_t)ch <= 0x1f) {
 86 |             char buf[8];
 87 |             snprintf(buf, sizeof buf, "\\u%04x", ch);
 88 |             out += buf;
 89 |         } else if ((uint8_t)ch == 0xe2 && (uint8_t)value[i+1] == 0x80
 90 |                    && (uint8_t)value[i+2] == 0xa8) {
 91 |             out += "\\u2028";
 92 |             i += 2;
 93 |         } else if ((uint8_t)ch == 0xe2 && (uint8_t)value[i+1] == 0x80
 94 |                    && (uint8_t)value[i+2] == 0xa9) {
 95 |             out += "\\u2029";
 96 |             i += 2;
 97 |         } else {
 98 |             out += ch;
 99 |         }
100 |     }
101 |     out += '"';
102 | }
103 | 
104 | static void dump(const Json::array &values, string &out) {
105 |     bool first = true;
106 |     out += "[";
107 |     for (auto &value : values) {
108 |         if (!first)
109 |             out += ", ";
110 |         value.dump(out);
111 |         first = false;
112 |     }
113 |     out += "]";
114 | }
115 | 
116 | static void dump(const Json::object &values, string &out) {
117 |     bool first = true;
118 |     out += "{";
119 |     for (const std::pair<string, Json> &kv : values) {
120 |         if (!first)
121 |             out += ", ";
122 |         dump(kv.first, out);
123 |         out += ": ";
124 |         kv.second.dump(out);
125 |         first = false;
126 |     }
127 |     out += "}";
128 | }
129 | 
130 | void Json::dump(string &out) const {
131 |     m_ptr->dump(out);
132 | }
133 | 
134 | /* * * * * * * * * * * * * * * * * * * *
135 |  * Value wrappers
136 |  */
137 | 
138 | template <Json::Type tag, typename T>
139 | class Value : public JsonValue {
140 | protected:
141 | 
142 |     // Constructors
143 |     Value(const T &value) : m_value(value) {}
144 |     Value(T &&value)      : m_value(move(value)) {}
145 | 
146 |     // Get type tag
147 |     Json::Type type() const {
148 |         return tag;
149 |     }
150 | 
151 |     // Comparisons
152 |     bool equals(const JsonValue * other) const {
153 |         return m_value == reinterpret_cast<const Value<tag, T> *>(other)->m_value;
154 |     }
155 |     bool less(const JsonValue * other) const {
156 |         return m_value < reinterpret_cast<const Value<tag, T> *>(other)->m_value;
157 |     }
158 | 
159 |     const T m_value;
160 |     void dump(string &out) const { json11::dump(m_value, out); }
161 | };
162 | 
163 | class JsonDouble final : public Value<Json::NUMBER, double> {
164 |     double number_value() const { return m_value; }
165 |     int int_value() const { return m_value; }
166 |     bool equals(const JsonValue * other) const { return m_value == other->number_value(); }
167 |     bool less(const JsonValue * other)   const { return m_value <  other->number_value(); }
168 | public:
169 |     JsonDouble(double value) : Value(value) {}
170 | };
171 | 
172 | class JsonInt final : public Value<Json::NUMBER, int> {
173 |     double number_value() const { return m_value; }
174 |     int int_value() const { return m_value; }
175 |     bool equals(const JsonValue * other) const { return m_value == other->number_value(); }
176 |     bool less(const JsonValue * other)   const { return m_value <  other->number_value(); }
177 | public:
178 |     JsonInt(double value) : Value(value) {}
179 | };
180 | 
181 | class JsonBoolean final : public Value<Json::BOOL, bool> {
182 |     bool bool_value() const { return m_value; }
183 | public:
184 |     JsonBoolean(bool value) : Value(value) {}
185 | };
186 | 
187 | class JsonString final : public Value<Json::STRING, string> {
188 |     const string &string_value() const { return m_value; }
189 | public:
190 |     JsonString(const string &value) : Value(value) {}
191 |     JsonString(string &&value)      : Value(move(value)) {}
192 | };
193 | 
194 | class JsonArray final : public Value<Json::ARRAY, Json::array> {
195 |     const Json::array &array_items() const { return m_value; }
196 |     const Json & operator[](size_t i) const;
197 | public:
198 |     JsonArray(const Json::array &value) : Value(value) {}
199 |     JsonArray(Json::array &&value)      : Value(move(value)) {}
200 | };
201 | 
202 | class JsonObject final : public Value<Json::OBJECT, Json::object> {
203 |     const Json::object &object_items() const { return m_value; }
204 |     const Json & operator[](const string &key) const;
205 | public:
206 |     JsonObject(const Json::object &value) : Value(value) {}
207 |     JsonObject(Json::object &&value)      : Value(move(value)) {}
208 | };
209 | 
210 | class JsonNull final : public Value<Json::NUL, std::nullptr_t> {
211 | public:
212 |     JsonNull() : Value(nullptr) {}
213 | };
214 | 
215 | /* * * * * * * * * * * * * * * * * * * *
216 |  * Static globals - static-init-safe
217 |  */
218 | struct Statics {
219 |     const std::shared_ptr<JsonValue> null = make_shared<JsonNull>();
220 |     const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true);
221 |     const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false);
222 |     const string empty_string;
223 |     const vector<Json> empty_vector;
224 |     const map<string, Json> empty_map;
225 |     Statics() {}
226 | };
227 | 
228 | const Statics & statics() {
229 |     static const Statics s {};
230 |     return s;
231 | }
232 | 
233 | const Json & static_null() {
234 |     // This has to be separate, not in Statics, because Json() accesses statics().null.
235 |     static const Json json_null;
236 |     return json_null;
237 | }
238 | 
239 | /* * * * * * * * * * * * * * * * * * * *
240 |  * Constructors
241 |  */
242 | 
243 | Json::Json() JSON11_NOEXCEPT                  : m_ptr(statics().null) {}
244 | Json::Json(std::nullptr_t) JSON11_NOEXCEPT    : m_ptr(statics().null) {}
245 | Json::Json(double value)                      : m_ptr(make_shared<JsonDouble>(value)) {}
246 | Json::Json(int value)                         : m_ptr(make_shared<JsonInt>(value)) {}
247 | Json::Json(bool value)                        : m_ptr(value ? statics().t : statics().f) {}
248 | Json::Json(const string &value)               : m_ptr(make_shared<JsonString>(value)) {}
249 | Json::Json(string &&value)                    : m_ptr(make_shared<JsonString>(move(value))) {}
250 | Json::Json(const char * value)                : m_ptr(make_shared<JsonString>(value)) {}
251 | Json::Json(const Json::array &values)         : m_ptr(make_shared<JsonArray>(values)) {}
252 | Json::Json(Json::array &&values)              : m_ptr(make_shared<JsonArray>(move(values))) {}
253 | Json::Json(const Json::object &values)        : m_ptr(make_shared<JsonObject>(values)) {}
254 | Json::Json(Json::object &&values)             : m_ptr(make_shared<JsonObject>(move(values))) {}
255 | 
256 | /* * * * * * * * * * * * * * * * * * * *
257 |  * Accessors
258 |  */
259 | 
260 | Json::Type Json::type()                           const { return m_ptr->type();         }
261 | double Json::number_value()                       const { return m_ptr->number_value(); }
262 | int Json::int_value()                             const { return m_ptr->int_value();    }
263 | bool Json::bool_value()                           const { return m_ptr->bool_value();   }
264 | const string & Json::string_value()               const { return m_ptr->string_value(); }
265 | const vector<Json> & Json::array_items()          const { return m_ptr->array_items();  }
266 | const map<string, Json> & Json::object_items()    const { return m_ptr->object_items(); }
267 | const Json & Json::operator[] (size_t i)          const { return (*m_ptr)[i];           }
268 | const Json & Json::operator[] (const string &key) const { return (*m_ptr)[key];         }
269 | 
270 | double                    JsonValue::number_value()              const { return 0; }
271 | int                       JsonValue::int_value()                 const { return 0; }
272 | bool                      JsonValue::bool_value()                const { return false; }
273 | const string &            JsonValue::string_value()              const { return statics().empty_string; }
274 | const vector<Json> &      JsonValue::array_items()               const { return statics().empty_vector; }
275 | const map<string, Json> & JsonValue::object_items()              const { return statics().empty_map; }
276 | const Json &              JsonValue::operator[] (size_t)         const { return static_null(); }
277 | const Json &              JsonValue::operator[] (const string &) const { return static_null(); }
278 | 
279 | const Json & JsonObject::operator[] (const string &key) const {
280 |     auto iter = m_value.find(key);
281 |     return (iter == m_value.end()) ? static_null() : iter->second;
282 | }
283 | const Json & JsonArray::operator[] (size_t i) const {
284 |     if (i >= m_value.size()) return static_null();
285 |     else return m_value[i];
286 | }
287 | 
288 | /* * * * * * * * * * * * * * * * * * * *
289 |  * Comparison
290 |  */
291 | 
292 | bool Json::operator== (const Json &other) const {
293 |     if (m_ptr->type() != other.m_ptr->type())
294 |         return false;
295 | 
296 |     return m_ptr->equals(other.m_ptr.get());
297 | }
298 | 
299 | bool Json::operator< (const Json &other) const {
300 |     if (m_ptr->type() != other.m_ptr->type())
301 |         return m_ptr->type() < other.m_ptr->type();
302 | 
303 |     return m_ptr->less(other.m_ptr.get());
304 | }
305 | 
306 | /* * * * * * * * * * * * * * * * * * * *
307 |  * Parsing
308 |  */
309 | 
310 | /* esc(c)
311 |  *
312 |  * Format char c suitable for printing in an error message.
313 |  */
314 | static inline string esc(char c) {
315 |     char buf[12];
316 |     if ((uint8_t)c >= 0x20 && (uint8_t)c <= 0x7f) {
317 |         snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
318 |     } else {
319 |         snprintf(buf, sizeof buf, "(%d)", c);
320 |     }
321 |     return string(buf);
322 | }
323 | 
324 | static inline bool in_range(long x, long lower, long upper) {
325 |     return (x >= lower && x <= upper);
326 | }
327 | 
328 | /* JsonParser
329 |  *
330 |  * Object that tracks all state of an in-progress parse.
331 |  */
332 | struct JsonParser {
333 | 
334 |     /* State
335 |      */
336 |     const string &str;
337 |     size_t i;
338 |     string &err;
339 |     bool failed;
340 | 
341 |     /* fail(msg, err_ret = Json())
342 |      *
343 |      * Mark this parse as failed.
344 |      */
345 |     Json fail(string &&msg) {
346 |         return fail(move(msg), Json());
347 |     }
348 | 
349 |     template <typename T>
350 |     T fail(string &&msg, const T err_ret) {
351 |         if (!failed)
352 |             err = std::move(msg);
353 |         failed = true;
354 |         return err_ret;
355 |     }
356 | 
357 |     /* consume_whitespace()
358 |      *
359 |      * Advance until the current character is non-whitespace.
360 |      */
361 |     void consume_whitespace() {
362 |         while (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t')
363 |             i++;
364 |     }
365 | 
366 |     /* get_next_token()
367 |      *
368 |      * Return the next non-whitespace character. If the end of the input is reached,
369 |      * flag an error and return 0.
370 |      */
371 |     char get_next_token() {
372 |         consume_whitespace();
373 |         if (i == str.size())
374 |             return fail("unexpected end of input", 0);
375 | 
376 |         return str[i++];
377 |     }
378 | 
379 |     /* encode_utf8(pt, out)
380 |      *
381 |      * Encode pt as UTF-8 and add it to out.
382 |      */
383 |     void encode_utf8(long pt, string & out) {
384 |         if (pt < 0)
385 |             return;
386 | 
387 |         if (pt < 0x80) {
388 |             out += pt;
389 |         } else if (pt < 0x800) {
390 |             out += (pt >> 6) | 0xC0;
391 |             out += (pt & 0x3F) | 0x80;
392 |         } else if (pt < 0x10000) {
393 |             out += (pt >> 12) | 0xE0;
394 |             out += ((pt >> 6) & 0x3F) | 0x80;
395 |             out += (pt & 0x3F) | 0x80;
396 |         } else {
397 |             out += (pt >> 18) | 0xF0;
398 |             out += ((pt >> 12) & 0x3F) | 0x80;
399 |             out += ((pt >> 6) & 0x3F) | 0x80;
400 |             out += (pt & 0x3F) | 0x80;
401 |         }
402 |     }
403 | 
404 |     /* parse_string()
405 |      *
406 |      * Parse a string, starting at the current position.
407 |      */
408 |     string parse_string() {
409 |         string out;
410 |         long last_escaped_codepoint = -1;
411 |         while (true) {
412 |             if (i == str.size())
413 |                 return fail("unexpected end of input in string", "");
414 | 
415 |             char ch = str[i++];
416 | 
417 |             if (ch == '"') {
418 |                 encode_utf8(last_escaped_codepoint, out);
419 |                 return out;
420 |             }
421 | 
422 |             if (in_range(ch, 0, 0x1f))
423 |                 return fail("unescaped " + esc(ch) + " in string", "");
424 | 
425 |             // The usual case: non-escaped characters
426 |             if (ch != '\\') {
427 |                 encode_utf8(last_escaped_codepoint, out);
428 |                 last_escaped_codepoint = -1;
429 |                 out += ch;
430 |                 continue;
431 |             }
432 | 
433 |             // Handle escapes
434 |             if (i == str.size())
435 |                 return fail("unexpected end of input in string", "");
436 | 
437 |             ch = str[i++];
438 | 
439 |             if (ch == 'u') {
440 |                 // Extract 4-byte escape sequence
441 |                 string esc = str.substr(i, 4);
442 |                 for (int j = 0; j < 4; j++) {
443 |                     if (!in_range(esc[j], 'a', 'f') && !in_range(esc[j], 'A', 'F')
444 |                             && !in_range(esc[j], '0', '9'))
445 |                         return fail("bad \\u escape: " + esc, "");
446 |                 }
447 | 
448 |                 long codepoint = strtol(esc.data(), nullptr, 16);
449 | 
450 |                 // JSON specifies that characters outside the BMP shall be encoded as a pair
451 |                 // of 4-hex-digit \u escapes encoding their surrogate pair components. Check
452 |                 // whether we're in the middle of such a beast: the previous codepoint was an
453 |                 // escaped lead (high) surrogate, and this is a trail (low) surrogate.
454 |                 if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
455 |                         && in_range(codepoint, 0xDC00, 0xDFFF)) {
456 |                     // Reassemble the two surrogate pairs into one astral-plane character, per
457 |                     // the UTF-16 algorithm.
458 |                     encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
459 |                                  | (codepoint - 0xDC00)) + 0x10000, out);
460 |                     last_escaped_codepoint = -1;
461 |                 } else {
462 |                     encode_utf8(last_escaped_codepoint, out);
463 |                     last_escaped_codepoint = codepoint;
464 |                 }
465 | 
466 |                 i += 4;
467 |                 continue;
468 |             }
469 | 
470 |             encode_utf8(last_escaped_codepoint, out);
471 |             last_escaped_codepoint = -1;
472 | 
473 |             if (ch == 'b') {
474 |                 out += '\b';
475 |             } else if (ch == 'f') {
476 |                 out += '\f';
477 |             } else if (ch == 'n') {
478 |                 out += '\n';
479 |             } else if (ch == 'r') {
480 |                 out += '\r';
481 |             } else if (ch == 't') {
482 |                 out += '\t';
483 |             } else if (ch == '"' || ch == '\\' || ch == '/') {
484 |                 out += ch;
485 |             } else {
486 |                 return fail("invalid escape character " + esc(ch), "");
487 |             }
488 |         }
489 |     }
490 | 
491 |     /* parse_number()
492 |      *
493 |      * Parse a double.
494 |      */
495 |     Json parse_number() {
496 |         size_t start_pos = i;
497 | 
498 |         if (str[i] == '-')
499 |             i++;
500 | 
501 |         // Integer part
502 |         if (str[i] == '0') {
503 |             i++;
504 |             if (in_range(str[i], '0', '9'))
505 |                 return fail("leading 0s not permitted in numbers");
506 |         } else if (in_range(str[i], '1', '9')) {
507 |             i++;
508 |             while (in_range(str[i], '0', '9'))
509 |                 i++;
510 |         } else {
511 |             return fail("invalid " + esc(str[i]) + " in number");
512 |         }
513 | 
514 |         if (str[i] != '.' && str[i] != 'e' && str[i] != 'E'
515 |                 && (i - start_pos) <= (size_t)std::numeric_limits<int>::digits10) {
516 |             return std::atoi(str.c_str() + start_pos);
517 |         }
518 | 
519 |         // Decimal part
520 |         if (str[i] == '.') {
521 |             i++;
522 |             if (!in_range(str[i], '0', '9'))
523 |                 return fail("at least one digit required in fractional part");
524 | 
525 |             while (in_range(str[i], '0', '9'))
526 |                 i++;
527 |         }
528 | 
529 |         // Exponent part
530 |         if (str[i] == 'e' || str[i] == 'E') {
531 |             i++;
532 | 
533 |             if (str[i] == '+' || str[i] == '-')
534 |                 i++;
535 | 
536 |             if (!in_range(str[i], '0', '9'))
537 |                 return fail("at least one digit required in exponent");
538 | 
539 |             while (in_range(str[i], '0', '9'))
540 |                 i++;
541 |         }
542 | 
543 |         return std::atof(str.c_str() + start_pos);
544 |     }
545 | 
546 |     /* expect(str, res)
547 |      *
548 |      * Expect that 'str' starts at the character that was just read. If it does, advance
549 |      * the input and return res. If not, flag an error.
550 |      */
551 |     Json expect(const string &expected, Json res) {
552 |         assert(i != 0);
553 |         i--;
554 |         const string found = str.substr(i, expected.length());
555 |         if (expected == found) {
556 |             i += expected.length();
557 |             return res;
558 |         } else {
559 |             return fail("parse error: expected " + expected + ", got " + found);
560 |         }
561 |     }
562 | 
563 |     /* parse_json()
564 |      *
565 |      * Parse a JSON object.
566 |      */
567 |     Json parse_json(int depth) {
568 |         if (depth > max_depth) {
569 |             return fail("exceeded maximum nesting depth");
570 |         }
571 | 
572 |         char ch = get_next_token();
573 |         if (failed)
574 |             return Json();
575 | 
576 |         if (ch == '-' || (ch >= '0' && ch <= '9')) {
577 |             i--;
578 |             return parse_number();
579 |         }
580 | 
581 |         if (ch == 't')
582 |             return expect("true", true);
583 | 
584 |         if (ch == 'f')
585 |             return expect("false", false);
586 | 
587 |         if (ch == 'n')
588 |             return expect("null", Json());
589 | 
590 |         if (ch == '"')
591 |             return parse_string();
592 | 
593 |         if (ch == '{') {
594 |             map<string, Json> data;
595 |             ch = get_next_token();
596 |             if (ch == '}')
597 |                 return data;
598 | 
599 |             while (1) {
600 |                 if (ch != '"')
601 |                     return fail("expected '\"' in object, got " + esc(ch));
602 | 
603 |                 string key = parse_string();
604 |                 if (failed)
605 |                     return Json();
606 | 
607 |                 ch = get_next_token();
608 |                 if (ch != ':')
609 |                     return fail("expected ':' in object, got " + esc(ch));
610 | 
611 |                 data[std::move(key)] = parse_json(depth + 1);
612 |                 if (failed)
613 |                     return Json();
614 | 
615 |                 ch = get_next_token();
616 |                 if (ch == '}')
617 |                     break;
618 |                 if (ch != ',')
619 |                     return fail("expected ',' in object, got " + esc(ch));
620 | 
621 |                 ch = get_next_token();
622 |             }
623 |             return data;
624 |         }
625 | 
626 |         if (ch == '[') {
627 |             vector<Json> data;
628 |             ch = get_next_token();
629 |             if (ch == ']')
630 |                 return data;
631 | 
632 |             while (1) {
633 |                 i--;
634 |                 data.push_back(parse_json(depth + 1));
635 |                 if (failed)
636 |                     return Json();
637 | 
638 |                 ch = get_next_token();
639 |                 if (ch == ']')
640 |                     break;
641 |                 if (ch != ',')
642 |                     return fail("expected ',' in list, got " + esc(ch));
643 | 
644 |                 ch = get_next_token();
645 |                 (void)ch;
646 |             }
647 |             return data;
648 |         }
649 | 
650 |         return fail("expected value, got " + esc(ch));
651 |     }
652 | };
653 | 
654 | Json Json::parse(const string &in, string &err) {
655 |     JsonParser parser { in, 0, err, false };
656 |     Json result = parser.parse_json(0);
657 | 
658 |     // Check for any trailing garbage
659 |     parser.consume_whitespace();
660 |     if (parser.i != in.size())
661 |         return parser.fail("unexpected trailing " + esc(in[parser.i]));
662 | 
663 |     return result;
664 | }
665 | 
666 | // Documented in json11.hpp
667 | vector<Json> Json::parse_multi(const string &in, string &err) {
668 |     JsonParser parser { in, 0, err, false };
669 | 
670 |     vector<Json> json_vec;
671 |     while (parser.i != in.size() && !parser.failed) {
672 |         json_vec.push_back(parser.parse_json(0));
673 |         // Check for another object
674 |         parser.consume_whitespace();
675 |     }
676 |     return json_vec;
677 | }
678 | 
679 | /* * * * * * * * * * * * * * * * * * * *
680 |  * Shape-checking
681 |  */
682 | 
683 | bool Json::has_shape(const shape & types, string & err) const {
684 |     if (!is_object()) {
685 |         err = "expected JSON object, got " + dump();
686 |         return false;
687 |     }
688 | 
689 |     for (auto & item : types) {
690 |         if ((*this)[item.first].type() != item.second) {
691 |             err = "bad type for " + item.first + " in " + dump();
692 |             return false;
693 |         }
694 |     }
695 | 
696 |     return true;
697 | }
698 | 
699 | } // namespace json11
700 | 
701 | #ifdef _MSC_VER
702 | #undef snprintf
703 | #endif
704 | 


--------------------------------------------------------------------------------