More tests

lib/bemhtml/index.js

@@ -115,9 +115,8 @@ BEMHTML.prototype.render = function render(context,
     if (cls)
       classValue += ' ' + (typeof cls === 'string' ?
                     utils.attrEscape(cls).trim() : cls);
-  } else {
-    if (cls)
-      classValue += cls.trim ? utils.attrEscape(cls).trim() : cls;
+  } else if (cls) {
+    classValue += cls.trim ? utils.attrEscape(cls).trim() : cls;
   }
 
   if (addJSInitClass)

lib/bemxjst/error.js

@@ -2,10 +2,7 @@ function BEMXJSTError(msg, func) {
   this.name = 'BEMXJSTError';
   this.message = msg;
 
-  if (Error.captureStackTrace)
-    Error.captureStackTrace(this, func || this.constructor);
-  else
-    this.stack = (new Error()).stack;
+  Error.captureStackTrace(this, func || this.constructor);
 }
 
 BEMXJSTError.prototype = Object.create(Error.prototype);

lib/bemxjst/match.js

@@ -5,16 +5,6 @@ var WrapMatch = tree.WrapMatch;
 var ExtendMatch = tree.ExtendMatch;
 var CustomMatch = tree.CustomMatch;
 
-function MatchProperty(template, pred) {
-  this.template = template;
-  this.key = pred.key;
-  this.value = pred.value;
-}
-
-MatchProperty.prototype.exec = function exec(context) {
-  return context[this.key] === this.value;
-};
-
 function MatchNested(template, pred) {
   this.template = template;
   this.keys = pred.key;
@@ -89,10 +79,7 @@ function MatchTemplate(mode, template) {
   for (var i = 0, j = 0; i < this.predicates.length; i++, j++) {
     var pred = template.predicates[i];
     if (pred instanceof PropertyMatch) {
-      if (Array.isArray(pred.key))
-        this.predicates[j] = new MatchNested(this, pred);
-      else
-        this.predicates[j] = new MatchProperty(this, pred);
+      this.predicates[j] = new MatchNested(this, pred);
     } else if (pred instanceof ExtendMatch) {
       j--;
       postpone.push(new MatchExtend(this));
@@ -141,17 +128,6 @@ function Match(entity, modeName) {
 }
 exports.Match = Match;
 
-Match.prototype.clone = function clone(entity) {
-  var res = new Match(entity, this.modeName);
-
-  res.templates = this.templates.slice();
-  res.mask = this.mask.slice();
-  res.maskSize = this.maskSize;
-  res.count = this.count;
-
-  return res;
-};
-
 Match.prototype.prepend = function prepend(other) {
   this.templates = other.templates.concat(this.templates);
   this.count += other.count;

test/api-generate-test.js

@@ -7,4 +7,10 @@ describe('API generate', function() {
 
     assert.equal(typeof bundle, 'string');
   });
+
+  it('should work with options', function() {
+    var bundle = bemxjst.generate('', { xhtml: true });
+
+    assert.equal(typeof bundle, 'string');
+  });
 });

test/flush-test.js

@@ -1,6 +1,8 @@
 var assert = require('assert');
 var fixtures = require('./fixtures')('bemhtml');
 var test = fixtures.test;
+var bemtreeFixtures = require('./fixtures')('bemtree');
+var bemtreeTest = bemtreeFixtures.test;
 
 describe('Flush', function() {
   it('should not flush custom def() bodies', function() {
@@ -77,4 +79,46 @@ describe('Flush', function() {
       }
     });
   });
+
+  it('should use _flush function', function() {
+    test(function() {
+      block('b').tag()('span');
+      block('br').tag()('br');
+    },
+    {
+      block: 'b',
+      content: { block: 'br' }
+    },
+    '',
+    {
+      xhtml: true,
+      flush: true,
+      after: function after(template) {
+        assert.deepEqual(template._buf, [
+          '<span class="b">',
+          '<br class="br"/>',
+          '</span>'
+        ]);
+      }
+    });
+  });
+
+  it('should use flush function in bemtree', function() {
+    bemtreeTest(function() {},
+    [
+      { block: 'br' },
+      { block: 'br' }
+    ],
+    '',
+    {
+      engine: 'BEMTREE',
+      flush: true,
+      after: function after(template) {
+        assert.deepEqual(template._buf, [
+          { block: 'br' },
+          { block: 'br' }
+        ]);
+      }
+    });
+  });
 });

test/templates-syntax-test.js

@@ -38,6 +38,16 @@ describe('Templates syntax', function() {
       fixtures.compile(function() {
         // No block() subpredicate
         elem('e').tag()('b');
+        elemMod('m', 'v').tag()('b');
+      });
+    }, BEMXJSTError);
+  });
+
+  it('should throw error when no block custom subpredicate', function() {
+    assert.throws(function() {
+      fixtures.compile(function() {
+        // No block() subpredicate
+        match(function() { return 1; }).tag()('b');
       });
     }, BEMXJSTError);
   });