sbis3-node-ws
Version:
Модуль позволяет использовать ядро интерфейсного фреймворка sbis3-ws(`core.js`) и модуль работы с данными (`Source.js`) в приложении на nodejs.
258 lines (256 loc) • 8.67 kB
JavaScript
/**
* Generating to AST to string step
*/
define('js!Core/tmpl/js/processing', [
'js!Core/tmpl/js/helpers/processExpressions',
'js!Core/tmpl/js/helpers/utils',
'js!Core/tmpl/js/helpers/whatType',
'js!Core/tmpl/js/astModules/module',
'js!Core/tmpl/js/helpers/entityHelpers',
'js!Core/tmpl/js/astModules/if',
'js!Core/tmpl/js/astModules/for',
'js!Core/tmpl/js/astModules/else',
'js!Core/tmpl/js/astModules/partial',
'js!Core/tmpl/js/astModules/include',
'js!Core/tmpl/js/astModules/template'
], function processingModule(processExpressions, utils, whatType, moduleC, entityHelpers, ifM, forM, elseM, par, inc, tmp) {
'use strict';
var processing = {
name: 'string',
/**Добавляем модули шаблонизатора для паковки. Паковщик по зависимостям плагинов не ходитo
* Modules for processing
*/
_modules: {
'if': ifM,
'for': forM,
'else': elseM,
'partial': par,
'include': inc,
'template': tmp
},
/**
* Modules in tag attributes
*/
_attributeModules: {
'if': ifM,
'for': forM
},
/**
* Getting html string
* @param {Array} ast AST array of entities
* @param {Object} data Data
* @return {String} Generated html-string
*/
getHTMLString: function getHTMLString(ast, data, handlers) {
if (handlers) {
this.calculators = handlers.config.calculators;
this.iterators = handlers.config.iterators;
this.filename = handlers.filename;
}
return this._process(ast, data);
},
/**
* Process requirable tag
* @param tag
* @param data
* @returns {Array}
*/
_processOptionModule: function processOptionModule(tag, data) {
return entityHelpers.loadModuleFunction.call(this, moduleC.module, tag, data);
},
/**
* Main function for finding process method for module
* @param {Object} tag Tag
* @param {Object} data Data object
* @return {Object} Entity: tag or text
*/
_processModule: function processModule(tag, data) {
var moduleFunction = entityHelpers.moduleMatcher.call(this, tag);
return entityHelpers.loadModuleFunction.call(this, moduleFunction, tag, data);
},
/**
* Handle modules for tag/constructions
* @param name
* @returns {Function}
*/
_handlingTag: function handlingTag(name) {
if (this._modules[utils.splitWs(name)]) {
return this._processModule;
}
if (entityHelpers.isTagRequirable(name)) {
return this._processOptionModule;
}
return this._processTag;
},
/**
* Resolving method to handle tree childs
* @param {Object} entity Tag, text, module
* @return {Function} Process function
*/
_whatMethodShouldYouUse: function whatMethodShouldYouUse(entity) {
if (entityHelpers.isTag(entity.type)) {
return this._handlingTag(entity.name);
}
if (entityHelpers.isText(entity.type)) {
return this._processText;
}
},
/**
* Concating arrays of entities
* @param {Object} entity Tag, text
* @return {String}
*/
_stopArrs: function stopArrs(entity) {
var string = '', i;
if (utils.isArray(entity)) {
for (i = 0; i < entity.length; i++) {
string += entity[i];
}
return string;
}
return entity;
},
/**
* Seek for methods
* @param {Object} entity Tag, text, module
* @param {Object} data Data object
* @return {String} Generated string
*/
_seek: function _seek(entity, data, prev, next) {
var method = this._whatMethodShouldYouUse(entity);
entity.prev = prev;
entity.next = next;
if (method) {
return this._stopArrs(method.call(this, entity, data));
}
},
/**
* Processing entity data objects
* @param {Array} textData Array of data
* @param {Object} data Data
* @return {String}
*/
_processData: function processData(textData, data) {
var string = '', i;
if (textData.length) {
for (i = 0; i < textData.length; i++) {
string += processExpressions(textData[i], data, this.calculators, this.filename) || '';
}
return string;
}
return processExpressions(textData, data, this.calculators, this.filename);
},
/**
* Process attributes
* @param {Object} attribs Tag attributes
* @param {Object} data Data
* @return {String}
*/
_processAttributes: function processAttributes(attribs, data) {
var string = '',
processed,
attrib;
if (attribs) {
for (attrib in attribs) {
if (attribs.hasOwnProperty(attrib) && attribs[attrib]) {
processed = this._processData(attribs[attrib].data, data);
if (utils.removeAllSpaces(processed) !== "") {
string += ' ' + (attrib + '="' + processed + '"');
}
}
}
}
return string;
},
/**
* Process Text entity
* @param {Object} text Text
* @param {Object} data Data
* @return {String}
*/
_processText: function processText(text, data) {
return this._processData(text.data, data);
},
/**
* Generating string tag
* @param tag
* @param data
* @returns {string}
*/
_generateTag: function generateTag(tag, data) {
if (tag.selfclosing) {
return '<' + tag.name + this._processAttributes(tag.attribs, data) + ' />';
}
return '<' + tag.name + this._processAttributes(tag.attribs, data) + '>' + this._process(tag.children, data) + '</' + tag.name + '>';
},
/**
* Process manageable attributes
* @param attribs
* @returns {Array}
*/
_processManageableAttributes: function processManageableAttributes(attribs) {
var constructArray = [], attrib;
for (attrib in attribs) {
if (this._attributeModules.hasOwnProperty(attrib) && attribs[attrib]) {
if (attrib === 'if') {
constructArray.unshift({ module: attrib, value: utils.clone(attribs[attrib]) });
} else {
constructArray.push({ module: attrib, value: utils.clone(attribs[attrib]) });
}
}
}
return constructArray;
},
/**
* Use manageable attributes on tag if exists
* @param tag
* @param data
* @returns {*}
*/
_useManageableAttributes: function useManageableAttributes(tag, data) {
var constructArray = this._processManageableAttributes(tag.attribs);
if (!!constructArray.length) {
return entityHelpers.loadModuleFunction.call(this, entityHelpers.attributeParserMatcherByName.call(this, constructArray.shift().module), tag, data);
}
return this._generateTag(tag, data);
},
/**
* Check for manageable attributes
* @param tag
* @param data
* @returns {*}
*/
_checkForManageableAttributes: function checkForManageableAttributes(tag, data) {
if (tag.attribs) {
return this._useManageableAttributes(tag, data);
}
return this._generateTag(tag, data);
},
/**
* Process Tag entity
* @param {Object} tag Tag
* @param {Object} data Array
* @return {String}
*/
_processTag: function processTag(tag, data) {
return this._checkForManageableAttributes(tag, data);
},
/**
* Recursive function for string generation
* @param {Array} ast AST array
* @param {Object} data Data
* @return {String}
*/
_process: function process(ast, data) {
var string = '', st;
for (var i = 0; i < ast.length; i++) {
st = this._seek(ast[i], data, ast[i-1], ast[i+1]);
if (st) {
string += st;
}
}
return string;
}
};
return processing;
});