fix: tech is null by default now

bem-sdk-archive · Oct 1, 2016 · 5de71b5 · 5de71b5
1 parent d9e6b2d
commit 5de71b5
Show file tree

Hide file tree

Showing 30 changed files with 243 additions and 243 deletions.
diff --git a/lib/normalize-harmony.js b/lib/normalize-harmony.js
@@ -39,7 +39,7 @@ module.exports = function (decl) {
         const str = naming.stringify(entity);
 
         if (!hash[str]) {
-            res.push({ entity: entity, tech: undefined });
+            res.push({ entity: entity, tech: null });
         }
 
         hash[str] = true;

diff --git a/lib/normalize.js b/lib/normalize.js
@@ -10,7 +10,7 @@ module.exports = function (decl) {
         const str = naming.stringify(entity);
 
         if (!hash[str]) {
-            res.push({ entity: entity, tech: undefined });
+            res.push({ entity: entity, tech: null });
         }
 
         hash[str] = true;

diff --git a/lib/normalize2.js b/lib/normalize2.js
@@ -26,7 +26,7 @@ module.exports = function (decl) {
             mod = getMod(entity) || null;
             val = entity.val;
             mods = getMods(entity);
-            tech = entity.tech;
+            tech = entity.tech || null;
         }
 
         // we should return block always if elems or mods given
@@ -137,7 +137,7 @@ module.exports = function (decl) {
         if (!hash[str]) {
             res.push({
                 entity: entity,
-                tech: tech
+                tech: tech || null
             });
         }
 

diff --git a/test/index.test.js b/test/index.test.js
@@ -15,20 +15,20 @@ test('should have `normalize` method', t => {
 test('should support `BEMDECL 1.0` format', t => {
     var decl = bemDecl.normalize(decls.v1);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 // TODO: define name of format
 test('should have support `BEMDECL x.0` format', t => {
     var decl = bemDecl.normalize(decls.v2, { v2: true });
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 })
 
 test('should support `BEMDECL 2.0` format', t => {
     var decl = bemDecl.normalize(decls.v2, { harmony: true });
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 test('should have `normalizer` method', t => {
@@ -38,32 +38,32 @@ test('should have `normalizer` method', t => {
 test('normalizer should support default value as `normalize`', t => {
     var decl = bemDecl.normalizer()(decls.v1);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 test('should support `BEMDECL 1.0` format through normalizer', t => {
     var decl = bemDecl.normalizer('normalize')(decls.v1);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 // TODO: define name of format
 test('should have support `BEMDECL x.0` format through normalizer', t => {
     var decl = bemDecl.normalizer('v2')(decls.v2);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 })
 
 test('should support `BEMDECL 2.0` format through normalizer', t => {
     var decl = bemDecl.normalizer('harmony')(decls.v2);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 test('should support uncorrect normalizer arg with default result', t => {
     var decl = bemDecl.normalizer('levoe')(decls.v1);
 
-    t.deepEqual(decl, [{ entity: decls.normalized, tech: undefined }]);
+    t.deepEqual(decl, [{ entity: decls.normalized, tech: null }]);
 });
 
 test('should have `merge` method', t => {

diff --git a/test/normalize-harmony/block.test.js b/test/normalize-harmony/block.test.js
@@ -6,9 +6,9 @@ const normalize = require('../../lib/normalize-harmony');
 test('should support block', t => {
     var block = { block: 'block' };
 
-    t.deepEqual(normalize(block), [{ entity: block, tech: undefined }]);
+    t.deepEqual(normalize(block), [{ entity: block, tech: null }]);
 });
 
 test('should support block as string', t => {
-    t.deepEqual(normalize(['block']), [{ entity: { block: 'block' }, tech: undefined }]);
+    t.deepEqual(normalize(['block']), [{ entity: { block: 'block' }, tech: null }]);
 });
diff --git a/test/normalize-harmony/common.test.js b/test/normalize-harmony/common.test.js
@@ -20,14 +20,14 @@ test('should support empty object', t => {
 test('should return set', t => {
     const A = { block: 'A' };
 
-    t.deepEqual(normalize([A, A]), [{ entity: A, tech: undefined }]);
+    t.deepEqual(normalize([A, A]), [{ entity: A, tech: null }]);
 });
 
 test('should save order', t => {
     const A = { block: 'A' },
         B = { block: 'B' };
 
-    t.deepEqual(normalize([A, B, A]), [{ entity: A, tech: undefined }, { entity: B, tech: undefined }]);
+    t.deepEqual(normalize([A, B, A]), [{ entity: A, tech: null }, { entity: B, tech: null }]);
 });
 
 test('should support array', t => {
@@ -37,7 +37,7 @@ test('should support array', t => {
     ];
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'A' }, tech: undefined },
-        { entity: { block: 'B' }, tech: undefined }
+        { entity: { block: 'A' }, tech: null },
+        { entity: { block: 'B' }, tech: null }
     ]);
 });
diff --git a/test/normalize-harmony/elem.test.js b/test/normalize-harmony/elem.test.js
@@ -7,38 +7,38 @@ test('should support elem', t => {
     const decl = { block: 'block', elem: 'elem' };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null }
     ]);
 });
 
 test('should support shortcut for bool mod of elem', t => {
     const decl = { block: 'block', elem: 'elem', modName: 'mod' };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null }
     ]);
 });
 
 test('should support bool mod of elem', t => {
     const decl = { block: 'block', elem: 'elem', modName: 'mod', modVal: true };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: true }, tech: null }
     ]);
 });
 
 test('should support elem mod', t => {
     const decl = { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
     ]);
 });
 
@@ -50,9 +50,9 @@ test('should support elem mods as object', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
     ]);
 });
 
@@ -64,10 +64,10 @@ test('should support bool mods of elem as array', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod-1', modVal: true }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod-2', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod-1', modVal: true }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod-2', modVal: true }, tech: null }
     ]);
 });
 
@@ -79,9 +79,9 @@ test('should support mod values of elem as array', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val-1' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val-2' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val-1' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val-2' }, tech: null }
     ]);
 });
diff --git a/test/normalize-harmony/elems.test.js b/test/normalize-harmony/elems.test.js
@@ -10,9 +10,9 @@ test('should support strings', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem-1' }, tech: undefined },
-        { entity: { block: 'block',  elem: 'elem-2' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem-1' }, tech: null },
+        { entity: { block: 'block',  elem: 'elem-2' }, tech: null }
     ]);
 });
 
@@ -23,8 +23,8 @@ test('should support objects', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null }
     ]);
 });
 
@@ -35,8 +35,8 @@ test('should support mods for elem objects', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem' }, tech: null },
+        { entity: { block: 'block', elem: 'elem', modName: 'mod', modVal: 'val' }, tech: null }
     ]);
 });
diff --git a/test/normalize-harmony/mix.test.js b/test/normalize-harmony/mix.test.js
@@ -11,10 +11,10 @@ test('should support mix', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem-1' }, tech: undefined },
-        { entity: { block: 'block', elem: 'elem-2' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod-1', modVal: true }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod-2', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', elem: 'elem-1' }, tech: null },
+        { entity: { block: 'block', elem: 'elem-2' }, tech: null },
+        { entity: { block: 'block', modName: 'mod-1', modVal: true }, tech: null },
+        { entity: { block: 'block', modName: 'mod-2', modVal: true }, tech: null }
     ]);
 });
diff --git a/test/normalize-harmony/mods.test.js b/test/normalize-harmony/mods.test.js
@@ -7,26 +7,26 @@ test('should support shortcut for bool mod', t => {
     const decl = { block: 'block', modName: 'mod' };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null }
     ]);
 });
 
 test('should support bool mod', t => {
     const decl = { block: 'block', modName: 'mod', modVal: true };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: true }, tech: null }
     ]);
 });
 
 test('should support mod', t => {
     const decl = { block: 'block', modName: 'mod', modVal: 'val' };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null }
     ]);
 });
 
@@ -37,8 +37,8 @@ test('should support mods as objects', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null }
     ]);
 });
 
@@ -49,9 +49,9 @@ test('should support bool mods as array', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod-1', modVal: true }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod-2', modVal: true }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod-1', modVal: true }, tech: null },
+        { entity: { block: 'block', modName: 'mod-2', modVal: true }, tech: null }
     ]);
 });
 
@@ -62,8 +62,8 @@ test('should support mod values as array', t => {
     };
 
     t.deepEqual(normalize(decl), [
-        { entity: { block: 'block' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: 'val-1' }, tech: undefined },
-        { entity: { block: 'block', modName: 'mod', modVal: 'val-2' }, tech: undefined }
+        { entity: { block: 'block' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: 'val-1' }, tech: null },
+        { entity: { block: 'block', modName: 'mod', modVal: 'val-2' }, tech: null }
     ]);
 });