LCOV - code coverage report
Current view: top level - templates/scriptabletags - scriptablenode.cpp (source / functions) Hit Total Coverage
Test: test_all.info Lines: 66 72 91.7 %
Date: 2011-06-24 Functions: 13 15 86.7 %
Branches: 79 168 47.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :   This file is part of the Grantlee template system.
       3                 :            : 
       4                 :            :   Copyright (c) 2009,2010 Stephen Kelly <steveire@gmail.com>
       5                 :            : 
       6                 :            :   This library is free software; you can redistribute it and/or
       7                 :            :   modify it under the terms of the GNU Lesser General Public
       8                 :            :   License as published by the Free Software Foundation; either version
       9                 :            :   2.1 of the Licence, or (at your option) any later version.
      10                 :            : 
      11                 :            :   This library is distributed in the hope that it will be useful,
      12                 :            :   but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14                 :            :   Lesser General Public License for more details.
      15                 :            : 
      16                 :            :   You should have received a copy of the GNU Lesser General Public
      17                 :            :   License along with this library.  If not, see <http://www.gnu.org/licenses/>.
      18                 :            : 
      19                 :            : */
      20                 :            : 
      21                 :            : #include "scriptablenode.h"
      22                 :            : 
      23                 :            : #include <QtScript/QScriptEngine>
      24                 :            : 
      25                 :            : #include "context.h"
      26                 :            : #include "scriptablecontext.h"
      27                 :            : #include "scriptableparser.h"
      28                 :            : #include "engine.h"
      29                 :            : #include "exception.h"
      30                 :            : #include "parser.h"
      31                 :            : 
      32         [ +  + ]:         25 : Q_DECLARE_METATYPE( Engine* )
      33                 :            : 
      34                 :          0 : QScriptValue nodeToScriptValue( QScriptEngine *engine, Node* const &node )
      35                 :            : {
      36                 :          0 :   return engine->newQObject( node );
      37                 :            : }
      38                 :            : 
      39                 :          7 : void nodeFromScriptValue( const QScriptValue &object, Node* &out )
      40                 :            : {
      41                 :          7 :   out = qobject_cast<Node*>( object.toQObject() );
      42                 :          7 : }
      43                 :            : 
      44                 :            : 
      45                 :            : Q_SCRIPT_DECLARE_QMETAOBJECT( ScriptableNode, Node* )
      46                 :            : 
      47                 :          7 : QScriptValue ScriptableNodeConstructor( QScriptContext *context,
      48                 :            :                                         QScriptEngine *engine )
      49                 :            : {
      50 [ +  - ][ +  - ]:         14 :   QString scriptableNodeName = context->argument( 0 ).toString();
      51 [ +  - ][ +  - ]:         14 :   QScriptValue concreteNode = engine->globalObject().property( scriptableNodeName );
         [ +  - ][ +  - ]
                 [ +  - ]
      52                 :            : 
      53 [ +  - ][ +  - ]:         14 :   QScriptValueList args;
      54                 :            :   // First is the node type
      55 [ +  - ][ +  + ]:         15 :   for ( int i = 1; i < context->argumentCount(); ++i ) {
      56 [ +  - ][ +  - ]:          8 :     args << context->argument( i );
                 [ +  - ]
      57                 :            :   }
      58                 :            : 
      59 [ +  - ][ +  - ]:          7 :   concreteNode.call( concreteNode, args );
      60                 :            : 
      61 [ +  - ][ +  - ]:         14 :   QScriptValue renderMethod = concreteNode.property( QLatin1String( "render" ) );
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
      62                 :            : 
      63 [ +  - ][ +  - ]:          7 :   ScriptableNode *object = new ScriptableNode( engine );
      64         [ +  - ]:          7 :   object->setObjectName( scriptableNodeName );
      65         [ +  - ]:          7 :   object->setScriptEngine( engine );
      66         [ +  - ]:          7 :   object->init( concreteNode, renderMethod );
      67 [ +  - ][ +  - ]:          7 :   return engine->newQObject( object );
      68                 :            : }
      69                 :            : 
      70                 :            : 
      71 [ +  - ][ +  - ]:          7 : ScriptableNode::ScriptableNode( QObject* parent ): Node( parent ), m_scriptEngine( 0 )
      72                 :            : {
      73                 :          7 : }
      74                 :            : 
      75                 :            : 
      76                 :          7 : void ScriptableNode::setScriptEngine( QScriptEngine *engine )
      77                 :            : {
      78                 :          7 :   m_scriptEngine = engine;
      79                 :          7 : }
      80                 :            : 
      81                 :          7 : void ScriptableNode::init( const QScriptValue &concreteNode,
      82                 :            :                            const QScriptValue &renderMethod )
      83                 :            : {
      84                 :          7 :   m_concreteNode = concreteNode;
      85                 :          7 :   m_renderMethod = renderMethod;
      86                 :          7 : }
      87                 :            : 
      88                 :          7 : void ScriptableNode::render( OutputStream *stream, Context *c )
      89                 :            : {
      90                 :         14 :   ScriptableContext sc( c );
      91 [ +  - ][ +  - ]:         14 :   QScriptValue contextObject = m_scriptEngine->newQObject( &sc );
                 [ +  - ]
      92                 :            : 
      93 [ +  - ][ +  - ]:         14 :   QScriptValueList args;
      94         [ +  - ]:          7 :   args << contextObject;
      95                 :            : 
      96                 :            :   // Call the render method in the context of the concreteNode
      97 [ +  - ][ +  - ]:         14 :   QScriptValue value = m_renderMethod.call( m_concreteNode, args );
      98                 :            : 
      99 [ +  - ][ +  - ]:          7 :   if ( value.isValid() && !value.isUndefined() )
         [ +  - ][ +  - ]
                 [ +  - ]
     100 [ +  - ][ +  - ]:          7 :     ( *stream ) << value.toString();
                 [ +  - ]
     101                 :          7 : }
     102                 :            : 
     103                 :         27 : ScriptableNodeFactory::ScriptableNodeFactory( QObject* parent )
     104         [ +  - ]:         27 :     : AbstractNodeFactory( parent ), m_scriptEngine( 0 )
     105                 :            : {
     106                 :            : 
     107                 :         27 : }
     108                 :            : 
     109                 :         25 : void ScriptableNodeFactory::setScriptEngine( QScriptEngine *engine )
     110                 :            : {
     111                 :         25 :   m_scriptEngine = engine;
     112                 :         25 : }
     113                 :            : 
     114                 :         25 : void ScriptableNodeFactory::setEngine( Engine* engine )
     115                 :            : {
     116         [ +  - ]:         25 :   m_scriptEngine->setProperty( "templateEngine", QVariant::fromValue( engine ) );
     117                 :         25 : }
     118                 :            : 
     119                 :         25 : void ScriptableNodeFactory::setFactory( QScriptValue factoryMethod )
     120                 :            : {
     121                 :         25 :   m_factoryMethod = factoryMethod;
     122                 :         25 : }
     123                 :            : 
     124                 :          7 : Node* ScriptableNodeFactory::getNode( const QString &tagContent, Parser *p ) const
     125                 :            : {
     126         [ -  + ]:          7 :   if ( m_scriptEngine->hasUncaughtException() ) {
     127 [ #  # ][ #  # ]:          0 :     throw Grantlee::Exception( TagSyntaxError, m_scriptEngine->uncaughtExceptionBacktrace().join( QChar::fromLatin1( ' ' ) ) );
                 [ #  # ]
     128                 :            :   }
     129         [ +  - ]:          7 :   ScriptableParser *sp = new ScriptableParser( p, m_scriptEngine );
     130                 :         14 :   QScriptValue parserObject = m_scriptEngine->newQObject( sp );
     131                 :            : 
     132 [ +  - ][ +  - ]:         14 :   QScriptValueList args;
     133 [ +  - ][ +  - ]:          7 :   args << tagContent;
                 [ +  - ]
     134         [ +  - ]:          7 :   args << parserObject;
     135                 :            : 
     136 [ +  - ][ +  - ]:         14 :   QScriptValue factory = m_factoryMethod;
     137                 :            : 
     138 [ +  - ][ +  - ]:         14 :   QScriptValue scriptNode = factory.call( factory, args );
     139 [ +  - ][ -  + ]:          7 :   if ( m_scriptEngine->hasUncaughtException() )
     140 [ #  # ][ #  # ]:          0 :     throw Grantlee::Exception( TagSyntaxError, m_scriptEngine->uncaughtExceptionBacktrace().join( QChar::fromLatin1( ' ' ) ) );
         [ #  # ][ #  # ]
                 [ #  # ]
     141                 :            : 
     142         [ +  - ]:          7 :   Node* node = qscriptvalue_cast<Node*>( scriptNode );
     143         [ +  - ]:          7 :   node->setParent( p );
     144                 :          7 :   return node;
     145                 :            : }
     146                 :            : 
     147                 :          0 : QScriptEngine* ScriptableNode::engine()
     148                 :            : {
     149                 :          0 :   return m_scriptEngine;
     150                 :            : }
     151                 :            : 
     152                 :          7 : void ScriptableNode::setNodeList( const QString &name, QObjectList objectList )
     153                 :            : {
     154                 :         14 :   QScriptValue objectListArray = m_scriptEngine->newArray( objectList.size() );
     155                 :            : 
     156 [ +  - ][ +  + ]:         18 :   for ( int i = 0; i < objectList.size(); ++i ) {
     157 [ +  - ][ +  - ]:         11 :     objectListArray.setProperty( i, m_scriptEngine->newQObject( objectList.at( i ) ) );
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     158                 :            :   }
     159 [ +  - ][ +  - ]:          7 :   m_concreteNode.setProperty( name, objectListArray );
     160                 :          7 : }
     161                 :            : 
     162                 :            : 
     163                 :            : #include "scriptablenode.moc"

Generated by: LCOV version 1.9