.builder(function (bhFilename, bemjsonFilename, allLangFilename, langFilename) {
dropRequireCache(require, bhFilename);
dropRequireCache(require, bemjsonFilename);
return vow.all([
asyncRequire(bhFilename),
requireOrEval(bemjsonFilename),
vfs.read(allLangFilename),
vfs.read(langFilename)
]).spread(function (bh, bemjson, allLangSource, langSource) {
vm.runInThisContext(allLangSource, allLangFilename);
vm.runInThisContext(langSource, langFilename);
return bh.apply(bemjson);
});
})
.then(function () {
if (cache.needRebuildFile('bemdecl-file', bemdeclFilename) ||
cache.needRebuildFile('bemjson-file', bemjsonFilename)
) {
return requireOrEval(bemjsonFilename)
.then(function (bemjson) {
var bemjsonDeps = getDepsFromBemjson(bemjson),
bemdecl = deps.toBemdecl(bemjsonDeps),
str = 'exports.blocks = ' + JSON.stringify(bemdecl, null, 4) + ';\n';
return vfs.write(bemdeclFilename, str, 'utf-8')
.then(function () {
cache.cacheFileInfo('bemdecl-file', bemdeclFilename);
cache.cacheFileInfo('bemjson-file', bemjsonFilename);
node.resolveTarget(target, { blocks: bemdecl });
});
});
} else {
node.isValidTarget(target);
dropRequireCache(require, bemdeclFilename);
return asyncRequire(bemdeclFilename)
.then(function (result) {
node.resolveTarget(target, result);
return null;
});
}
});
.builder(function (keysetsFilename) {
dropRequireCache(require, keysetsFilename);
var lang = this._lang;
var keysets = require(keysetsFilename);
var res = [];
Object.keys(keysets).sort().map(function (keysetName) {
var keyset = keysets[keysetName];
res.push('<keyset id="' + keysetName + '">');
Object.keys(keyset).map(function (key) {
var value = keyset[key];
var dom = new domjs.DomJS();
try {
dom.parse('<root>' + value + '</root>', function () {});
} catch (e) {
value = domjs.escape(value);
}
res.push('<key id="' + key + '">');
res.push('<value>' + value + '</value>');
res.push('</key>');
});
res.push('</keyset>');
});
return this.getPrependXml(lang) + res.join('\n') + this.getAppendXml(lang);
})
.spread(function (fromDeps, whatDeps) {
if (cache.needRebuildFile('deps-file', targetFilename) ||
cache.needRebuildFile('deps-from-file', fromFilename) ||
cache.needRebuildFile('deps-what-file', whatFilename)
) {
return vow.all([
requireDeps(fromDeps, fromFilename),
requireDeps(whatDeps, whatFilename)
])
.spread(function (from, what) {
var subtractedDeps = deps.subtract(from.deps, what.deps),
str = 'exports.deps = ' + JSON.stringify(subtractedDeps, null, 4) + ';';
return vfs.write(targetFilename, str, 'utf-8')
.then(function () {
cache.cacheFileInfo('deps-file', targetFilename);
cache.cacheFileInfo('deps-from-file', fromFilename);
cache.cacheFileInfo('deps-what-file', whatFilename);
node.resolveTarget(target, { deps: subtractedDeps });
});
});
} else {
node.isValidTarget(target);
dropRequireCache(require, targetFilename);
return asyncRequire(targetFilename)
.then(function (result) {
node.resolveTarget(target, result);
return null;
});
}
});
.builder(function(bemtreeFilename, bemhtmlFilename) {
dropRequireCache(require, bemhtmlFilename);
return vow.all([
vfs.read(bemtreeFilename, 'utf-8'),
asyncRequire(bemhtmlFilename)
])
.spread(function(bemtree, bemhtml) {
var ctx = vm.createContext({
Vow : vow,
console : console,
setTimeout : setTimeout
});
vm.runInContext(bemtree, ctx);
return [ctx.BEMTREE, bemhtml.BEMHTML];
})
.spread(function(BEMTREE, BEMHTML) {
return BEMTREE.apply({})
.then(function(bemjson) {
return BEMHTML.apply(bemjson);
});
});
})
.builder(function (keysetsFilename) {
var node = this.node,
cache = node.getNodeCache(this._target),
basename = path.basename(keysetsFilename),
cacheKey = 'keysets-file-' + basename,
promise;
if (cache.needRebuildFile(cacheKey, keysetsFilename)) {
dropRequireCache(require, keysetsFilename);
promise = asyncRequire(keysetsFilename)
.then(function (keysets) {
cache.cacheFileInfo(cacheKey, keysetsFilename);
return keysets;
});
} else {
promise = asyncRequire(keysetsFilename);
}
return promise.then(function (keysets) {
var lang = this._lang,
res = Object.keys(keysets).sort().reduce(function (prev, keysetName) {
prev.push(this.__self.getKeysetBuildResult(keysetName, keysets[keysetName], lang));
return prev;
}.bind(this), []);
return this.getPrependJs(lang) + res.join('\n\n') + this.getAppendJs(lang);
}, this);
})
TestTarget.prototype.require = function () {
global.REQUIRED_TECHS = [];
dropRequireCache(require, this._targetAbsolutePath);
require(this._targetRelativePath);
return global.REQUIRED_TECHS;
};
.builder(function (bhFilename, bemjsonFilename) {
dropRequireCache(require, bemjsonFilename);
return requireOrEval(bemjsonFilename).then(function (json) {
dropRequireCache(require, bhFilename);
return asyncRequire(bhFilename).then(function (bh) {
return bh.apply(json);
});
});
})
return vow.all(sourceDeps.map(function (source, i) {
if (source) { return source.deps; }
var filename = sourceFilenames[i];
dropRequireCache(require, filename);
return asyncRequire(filename)
.then(function (res) {
return res.deps;
});
}))
return asyncRequire(bemtreeFilename).then(function (bemtree) {
dropRequireCache(require, bemhtmlFilename);
return asyncRequire(bemhtmlFilename).then(function (bemhtml) {
return bemtree.BEMTREE.apply({}).then(function (bemjson) {
if(!bemhtml.BEMHTML && bemhtml.lib) {
return bemhtml.apply(bemjson);
} else {
return bemhtml.BEMHTML.apply(bemjson);
}
});
});
});
function requireSourceDeps(data, filename) {
return (data ? vow.resolve(data) : (
dropRequireCache(require, filename),
asyncRequire(filename)
))
.then(function (sourceDeps) {
if (sourceDeps.blocks) {
return deps.fromBemdecl(sourceDeps.blocks);
}
return sourceDeps.deps;
});
}
vow.all(bemjsons.map(function (file) {
var name = file.name,
lang = file.lang,
filename = file.fullname;
dropRequireCache(require, filename);
return requireOrEval(filename)
.then(function (code) {
return {
name: name,
lang: lang,
code: code
};
});
})),
return this.node.requireSources(sourcesToRequire).spread(function (sources) {
var depFiles = [].concat.apply([], suffixes.map(function (suffix) {
return sources.getFilesBySuffix(suffix);
}));
if (cache.needRebuildFile('deps-file', targetPath) ||
(sourceDepsFilename ? cache.needRebuildFile('source-file', sourceDepsFilename) : false) ||
cache.needRebuildFileList('deps-file-list', depFiles)
) {
var sourceReadPromise;
if (sourceDeps) {
sourceReadPromise = vow.fulfill(sourceDeps);
} else {
var format = new YamlFormat();
sourceReadPromise = vowFs.read(sourceDepsFilename, 'utf8').then(function (depsContent) {
return format.processFile(sourceDepsFilename, depsContent);
});
}
return sourceReadPromise.then(function (startingDeps) {
var depsResolver = new DepsResolver(sources, jsSuffixes.map(function (suffix) {
return new ModulesFormat(suffix);
}).concat(new YamlFormat()));
return depsResolver.addDecls(depsResolver.normalizeDeps(startingDeps)).then(function () {
var resolvedDeps = depsResolver.resolve();
return vowFs.write(
targetPath, 'module.exports = ' + JSON.stringify(resolvedDeps, null, 4) + ';\n', 'utf8'
).then(function () {
cache.cacheFileInfo('deps-file', targetPath);
if (sourceDepsFilename) {
cache.cacheFileInfo('source-file', sourceDepsFilename);
}
cache.cacheFileList('deps-file-list', depFiles);
_this.node.resolveTarget(target, resolvedDeps);
});
});
});
} else {
dropRequireCache(require, targetPath);
return asyncRequire(targetPath).then(function (value) {
_this.node.isValidTarget(target);
_this.node.resolveTarget(target, value);
});
}
});
.spread(function (levels, sourceDeps) {
var depFiles = levels.getFilesBySuffix('deps.js').concat(levels.getFilesBySuffix('deps.yaml'));
if (cache.needRebuildFile('deps-file', targetFilename) ||
cache.needRebuildFile('decl-file', declFilename) ||
cache.needRebuildFileList('deps-file-list', depFiles)
) {
return requireSourceDeps(sourceDeps, declFilename)
.then(function (sourceDeps) {
var resolver = new DepsResolver(levels),
decls = resolver.normalizeDeps(sourceDeps);
return resolver.addDecls(decls)
.then(function () {
var resolvedDeps = resolver.resolve(),
str = 'exports.deps = ' + JSON.stringify(resolvedDeps, null, 4) + ';\n';
return vfs.write(targetFilename, str, 'utf8')
.then(function () {
cache.cacheFileInfo('deps-file', targetFilename);
cache.cacheFileInfo('decl-file', declFilename);
cache.cacheFileList('deps-file-list', depFiles);
node.resolveTarget(target, { deps: resolvedDeps });
});
});
});
} else {
node.isValidTarget(target);
dropRequireCache(require, targetFilename);
return asyncRequire(targetFilename)
.then(function (result) {
node.resolveTarget(target, result);
return null;
});
}
});
.then(function (sourceDeps) {
if (cache.needRebuildFile('deps-file', targetFilename) ||
cache.needRebuildFileList('source-file-list', sourceFilenames)
) {
return vow.all(sourceDeps.map(function (source, i) {
if (source) { return source.deps; }
var filename = sourceFilenames[i];
dropRequireCache(require, filename);
return asyncRequire(filename)
.then(function (res) {
return res.deps;
});
}))
.then(function (sourceDeps) {
var mergedDeps = deps.merge(sourceDeps),
str = 'exports.deps = ' + JSON.stringify(mergedDeps, null, 4) + ';';
return vfs.write(targetFilename, str, 'utf-8')
.then(function () {
cache.cacheFileInfo('deps-file', targetFilename);
cache.cacheFileList('source-file-list', sourceFilenames);
_this.node.resolveTarget(target, { deps: mergedDeps });
});
});
} else {
node.isValidTarget(target);
dropRequireCache(require, targetFilename);
return asyncRequire(targetFilename)
.then(function (result) {
node.resolveTarget(target, result);
return null;
});
}
});
return enbBuilder(assetPath).then(function (fileName) {
dropRequireCache(require, fileName);
return require(fileName);
});
.spread(function (files) {
if (cache.needRebuildFile('bemdecl-file', bemdeclFilename) ||
cache.needRebuildFile('files-file', filesFilename)
) {
var depsFiles = files.bySuffix['deps.js'] || [];
return vow.all(depsFiles.map(function (file) {
return vfs.read(file.fullname, 'utf8').then(function (text) {
return { file: file, text: text };
});
})).then(function (depResults) {
var result = [],
depIndex = {};
depResults.forEach(function (depResult) {
var fileDeps = vm.runInThisContext(depResult.text),
bemname = depResult.file.name.split('.')[0],
notation = naming.parse(bemname);
if (!fileDeps) {
return;
}
fileDeps = Array.isArray(fileDeps) ? fileDeps : [fileDeps];
fileDeps.forEach(function (dep) {
if (dep.tech === sourceTech) {
['mustDeps', 'shouldDeps'].forEach(function (depType) {
if (dep[depType]) {
deps.flattenDeps(dep[depType]).forEach(function (singleDep) {
singleDep.block || (singleDep.block = notation.block);
if (singleDep.tech === destTech) {
var key = depKey(singleDep);
if (!depIndex[key]) {
depIndex[key] = true;
result.push(singleDep);
}
}
});
}
});
}
});
});
var blocks = deps.toBemdecl(result),
str = 'exports.blocks = ' + JSON.stringify(blocks, null, 4) + ';\n';
return vfs.write(bemdeclFilename, str, 'utf-8')
.then(function () {
cache.cacheFileInfo('bemdecl-file', bemdeclFilename);
cache.cacheFileInfo('files-file', filesFilename);
node.resolveTarget(target, { blocks: blocks });
});
});
} else {
node.isValidTarget(target);
dropRequireCache(require, bemdeclFilename);
return asyncRequire(bemdeclFilename)
.then(function (result) {
node.resolveTarget(target, result);
return null;
});
}
});
function requireBemdecl(data, filename) {
if (data) { return vow.resolve(data); }
dropRequireCache(require, filename);
return asyncRequire(filename);
}
function requireDeps(deps, filename) {
if (deps) { return deps; }
dropRequireCache(require, filename);
return asyncRequire(filename);
}
files.map(function(file) {
var key = path.join(dir, file);
dropRequireCache(require, key);
});
return enbBuilder(target).then(function() {
dropRequireCache(require, target);
return target;
});
return this._builder(item).then(function () {
dropRequireCache(require, item);
return item;
}, this);