Fix intersect

bem-sdk-archive · Nov 25, 2016 · f6a5d8e · f6a5d8e
1 parent cd5c19b
commit f6a5d8e
Show file tree

Hide file tree

Showing 4 changed files with 73 additions and 53 deletions.
diff --git a/lib/intersect.js b/lib/intersect.js
@@ -7,23 +7,24 @@ module.exports = function () {
     const res = [];
 
     let decl;
-    let entity, key, val;
+    let item, entity, key, val;
     let i, j, l, dl;
 
     for (i = 0, l = arguments.length; i < l; ++i) {
         decl = arguments[i];
 
         for (j = 0, dl = decl.length; j < dl; ++j) {
-            entity = decl[j];
-            key = naming.stringify(entity);
+            item = decl[j];
+            entity = item.entity;
+            key = naming.stringify(entity) + item.tech;
             val = hash[key];
 
             if (!val) {
                 // mark entity
                 hash[key] = 1;
             } else if (val === 1) {
                 // add if entity has been mark
-                res.push(entity);
+                res.push(item);
 
                 // to not add twice
                 hash[key] = 2;

diff --git a/test/intersect/disjoint-entities.test.js b/test/intersect/disjoint-entities.test.js
@@ -4,78 +4,78 @@ const test = require('ava');
 const intersect = require('../../lib/intersect');
 
 test('should not intersect other entities from block', t => {
-    const decl1 = [{ block: 'block' }];
+    const decl1 = [{ entity: { block: 'block' }, tech: null }];
     const decl2 = [
-        { block: 'block', modName: 'mod', modVal: true },
-        { block: 'block', modName: 'mod', modVal: 'val' },
-        { block: 'block', elem: 'elem' },
-        { block: 'block', elem: 'elem', modName: 'mod', modVal: true },
-        { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }
+        { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
     ];
 
     t.deepEqual(intersect(decl1, decl2), []);
 });
 
 test('should not intersect other entities from bool mod', t => {
-    const decl1 = [{ block: 'block', modName: 'mod', modVal: true }];
+    const decl1 = [{ entity: { block: 'block', modName: 'mod', modVal: true }, tech: null }];
     const decl2 = [
-            { block: 'block' },
-            { block: 'block', modName: 'mod', modVal: 'val' },
-            { block: 'block', elem: 'elem' },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: true },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }
+            { entity: { block: 'block' }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null },
+            { entity: { block: 'block', elem: 'elem' }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
         ];
 
     t.deepEqual(intersect(decl1, decl2), []);
 });
 
 test('should not intersect other entities from mod', t => {
-    const decl1 = [{ block: 'block', modName: 'mod', modVal: 'val' }];
+    const decl1 = [{ entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null }];
     const decl2 = [
-            { block: 'block' },
-            { block: 'block', modName: 'mod', modVal: true },
-            { block: 'block', elem: 'elem' },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: true },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }
+            { entity: { block: 'block' }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', elem: 'elem' }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
         ];
 
     t.deepEqual(intersect(decl1, decl2), []);
 });
 
 test('should not intersect other entities from elem', t => {
-    const decl1 = [{ block: 'block', elem: 'elem' }];
+    const decl1 = [{ entity: { block: 'block', elem: 'elem' }, tech: null }];
     const decl2 = [
-            { block: 'block' },
-            { block: 'block', modName: 'mod', modVal: true },
-            { block: 'block', modName: 'mod', modVal: 'val' },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: true },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }
+            { entity: { block: 'block' }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null },
         ];
 
     t.deepEqual(intersect(decl1, decl2), []);
 });
 
 test('should not intersect other entities from bool mod of elem', t => {
-    const decl1 = [{ block: 'block', elem: 'elem',  modName: 'mod', modVal: true }];
+    const decl1 = [{ entity: { block: 'block', elem: 'elem',  modName: 'mod', modVal: true }, tech: null }];
     const decl2 = [
-            { block: 'block' },
-            { block: 'block', modName: 'mod', modVal: true },
-            { block: 'block', modName: 'mod', modVal: 'val' },
-            { block: 'block', elem: 'elem' },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }
+            { entity: { block: 'block' }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null },
+            { entity: { block: 'block', elem: 'elem' }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
         ];
 
     t.deepEqual(intersect(decl1, decl2), []);
 });
 
 test('should not intersect other entities from mod of elem', t => {
-    const decl1 = [{ block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }];
+    const decl1 = [{ entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }];
     const decl2 = [
-            { block: 'block' },
-            { block: 'block', modName: 'mod', modVal: true },
-            { block: 'block', modName: 'mod', modVal: 'val' },
-            { block: 'block', elem: 'elem' },
-            { block: 'block', elem: 'elem', modName: 'mod', modVal: true }
+            { entity: { block: 'block' }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null },
+            { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null },
+            { entity: { block: 'block', elem: 'elem' }, tech: null },
+            { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null }
         ];
 
     t.deepEqual(intersect(decl1, decl2), []);

diff --git a/test/intersect/intersecting-entities.test.js b/test/intersect/intersecting-entities.test.js
@@ -4,37 +4,37 @@ const test = require('ava');
 const intersect = require('../../lib/intersect');
 
 test('should intersect block with block', t => {
-    const block = [{ block: 'block' }];
+    const block = [{ entity: { block: 'block' }, tech: null }];
 
     t.deepEqual(intersect(block, block), block);
 });
 
 test('should intersect bool mod with bool mod', t => {
-    const mod = [{ block: 'block', modName: 'mod', modVal: true }];
+    const mod = [{ entity: { block: 'block', modName: 'mod', modVal: true }, tech: null }];
 
     t.deepEqual(intersect(mod, mod), mod);
 });
 
 test('should intersect mod with mod', t => {
-    const mod = [{ block: 'block', modName: 'mod', modVal: 'val' }];
+    const mod = [{ entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null }];
 
     t.deepEqual(intersect(mod, mod), mod);
 });
 
 test('should intersect elem with elem', t => {
-    const elem = [{ block: 'block', elem: 'elem' }];
+    const elem = [{ entity: { block: 'block', elem: 'elem' }, tech: null }];
 
     t.deepEqual(intersect(elem, elem), elem);
 });
 
 test('should intersect bool mod of elem with bool mod of elem', t => {
-    const mod = [{ block: 'block', elem: 'elem' , modName: 'mod', modVal: true }];
+    const mod = [{ entity: { block: 'block', elem: 'elem' , modName: 'mod', modVal: true }, tech: null }];
 
     t.deepEqual(intersect(mod, mod), mod);
 });
 
 test('should intersect elem mod with elem mod', t => {
-    const mod = [{ block: 'block', elem: 'elem' , modName: 'mod', modVal: 'val' }];
+    const mod = [{ entity: { block: 'block', elem: 'elem' , modName: 'mod', modVal: 'val' }, tech: null }];
 
     t.deepEqual(intersect(mod, mod), mod);
 });
diff --git a/test/intersect/sets.test.js b/test/intersect/sets.test.js
@@ -4,33 +4,52 @@ const test = require('ava');
 const intersect = require('../../lib/intersect');
 
 test('should support only one decl', t => {
-    const decl = [{ block: 'block' }];
+    const decl = [{ entity: { block: 'block' }, tech: null }];
 
     t.deepEqual(intersect(decl), []);
 });
 
 test('should support several decls', t => {
-    const block = [{ block: 'block' }];
+    const block = [{ entity: { block: 'block' }, tech: null }];
 
     t.deepEqual(intersect(block, block, block, block), block);
 });
 
 test('should intersect set with empty set', t => {
-    const decl = [{ block: 'block' }];
+    const decl = [{ entity: { block: 'block' }, tech: null }];
 
     t.deepEqual(intersect(decl, []), []);
 });
 
 test('should intersect disjoint sets', t => {
-    const A = [{ block: 'A' }];
-    const B = [{ block: 'B' }];
+    const A = [{ entity: { block: 'A' }, tech: null }];
+    const B = [{ entity: { block: 'B' }, tech: null }];
 
     t.deepEqual(intersect(A, B), []);
 });
 
 test('should intersect intersecting sets', t => {
-    const ABC = [{ block: 'A' }, { block: 'B' }, { block: 'C' }];
-    const B = [{ block: 'B' }];
+    const ABC = [
+        { entity: { block: 'A' }, tech: null },
+        { entity: { block: 'B' }, tech: null },
+        { entity: { block: 'C' }, tech: null }
+    ];
+    const B = [{ entity: { block: 'B' }, tech: null }];
 
     t.deepEqual(intersect(ABC, B), B);
 });
+
+test('should intersect intersecting sets with different techs', t => {
+    const common = { entity: { block: 'C' }, tech: 't1' };
+    const ABC = [
+        { entity: { block: 'A' }, tech: null },
+        { entity: { block: 'B' }, tech: 't1' },
+        common
+    ];
+    const B = [
+        { entity: { block: 'B' }, tech: 't2' },
+        common
+    ];
+
+    t.deepEqual(intersect(ABC, B), [common]);
+});