Merge pull request #92 from bem/issue-91

fix: functions should working without context

Author: blond

index.js

@@ -123,18 +123,18 @@ function createNaming(options) {
         var res = obj.block;
 
         if (obj.elem) {
-            res += this.elemDelim + obj.elem;
+            res += delims.elem + obj.elem;
         }
 
         if (obj.modName) {
             var modVal = obj.modVal;
 
             if (modVal || modVal === 0 || !obj.hasOwnProperty('modVal')) {
-                res += this.modDelim + obj.modName;
+                res += delims.mod.name + obj.modName;
             }
 
             if (modVal && modVal !== true) {
-                res += this.modValDelim + modVal;
+                res += delims.mod.val + modVal;
             }
         }
 

test/presets/original/is-block-mod.test.js

@@ -2,11 +2,12 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const isBlockMod = naming.isBlockMod;
 
 test('should detect mod of block', t => {
-    t.true(naming.isBlockMod('block_mod_val'));
+    t.true(isBlockMod('block_mod_val'));
 });
 
 test('should detect boolean mod of block', t => {
-    t.true(naming.isBlockMod('block_mod'));
+    t.true(isBlockMod('block_mod'));
 });

test/presets/original/is-elem-mod.test.js

@@ -2,11 +2,12 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const isElemMod = naming.isElemMod;
 
 test('should detect mod of elem', t => {
-    t.true(naming.isElemMod('block__elem_mod_val'));
+    t.true(isElemMod('block__elem_mod_val'));
 });
 
 test('should detect boolean mod of elem', t => {
-    t.true(naming.isElemMod('block__elem_mod'));
+    t.true(isElemMod('block__elem_mod'));
 });

test/presets/original/is-elem.test.js

@@ -2,7 +2,8 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const isElem = naming.isElem;
 
 test('should detect elem', t => {
-    t.true(naming.isElem('block__elem'));
+    t.true(isElem('block__elem'));
 });

test/presets/original/parse.test.js

@@ -2,59 +2,60 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const parse = naming.parse;
 
 test('should not parse not valid string', t => {
-    const obj = naming.parse('(*)_(*)');
+    const obj = parse('(*)_(*)');
 
     t.is(obj, undefined);
 });
 
 test('should have one filed if parse block', t => {
-    const obj = naming.parse('block');
+    const obj = parse('block');
 
     t.is(Object.keys(obj).length, 1);
 });
 
 test('should have three filed if parse mod of block', t => {
-    const obj = naming.parse('block_mod_val');
+    const obj = parse('block_mod_val');
 
     t.is(Object.keys(obj).length, 3);
 });
 
 test('should have three filed if parse boolean mod of block', t => {
-    const obj = naming.parse('block_mod');
+    const obj = parse('block_mod');
 
     t.is(Object.keys(obj).length, 3);
 });
 
 test('should have two filed if parse elem of block', t => {
-    const obj = naming.parse('block__elem');
+    const obj = parse('block__elem');
 
     t.is(Object.keys(obj).length, 2);
 });
 
 test('should have four filed if parse mod of elem', t => {
-    const obj = naming.parse('block__elem_mod_val');
+    const obj = parse('block__elem_mod_val');
 
     t.is(Object.keys(obj).length, 4);
 });
 
 test('should have four filed if parse boolean mod of elem', t => {
-    const obj = naming.parse('block__elem_mod');
+    const obj = parse('block__elem_mod');
 
     t.is(Object.keys(obj).length, 4);
 });
 
 test('should parse block', t => {
-    const obj = naming.parse('block');
+    const obj = parse('block');
 
     t.is(obj.block, 'block');
 });
 
 test('should parse mod of block', t => {
     t.plan(3);
 
-    const obj = naming.parse('block_mod_val');
+    const obj = parse('block_mod_val');
 
     t.is(obj.block, 'block');
     t.is(obj.modName, 'mod');
@@ -64,7 +65,7 @@ test('should parse mod of block', t => {
 test('should parse boolean mod of block', t => {
     t.plan(3);
 
-    const obj = naming.parse('block_mod');
+    const obj = parse('block_mod');
 
     t.is(obj.block, 'block');
     t.is(obj.modName, 'mod');
@@ -75,7 +76,7 @@ test('should parse boolean mod of block', t => {
 test('should parse elem', t => {
     t.plan(2);
 
-    const obj = naming.parse('block__elem');
+    const obj = parse('block__elem');
 
     t.is(obj.block, 'block');
     t.is(obj.elem, 'elem');
@@ -84,7 +85,7 @@ test('should parse elem', t => {
 test('should parse mod of elem', t => {
     t.plan(4);
 
-    const obj = naming.parse('block__elem_mod_val');
+    const obj = parse('block__elem_mod_val');
 
     t.is(obj.block, 'block');
     t.is(obj.elem, 'elem');
@@ -95,7 +96,7 @@ test('should parse mod of elem', t => {
 test('should parse boolean mod of elem', t => {
     t.plan(4);
 
-    const obj = naming.parse('block__elem_mod');
+    const obj = parse('block__elem_mod');
 
     t.is(obj.block, 'block');
     t.is(obj.elem, 'elem');

test/presets/original/stringify.test.js

@@ -2,15 +2,16 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const stringify = naming.stringify;
 
 test('should stringify block', t => {
-    const str = naming.stringify({ block: 'block' });
+    const str = stringify({ block: 'block' });
 
     t.is(str, 'block');
 });
 
 test('should stringify mod of block', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         modName: 'mod',
         modVal: 'val'
@@ -20,7 +21,7 @@ test('should stringify mod of block', t => {
 });
 
 test('should stringify boolean mod of block', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         modName: 'mod'
     });
@@ -29,7 +30,7 @@ test('should stringify boolean mod of block', t => {
 });
 
 test('should stringify boolean mod of block by strict notation', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         modName: 'mod',
         modVal: true
@@ -39,7 +40,7 @@ test('should stringify boolean mod of block by strict notation', t => {
 });
 
 test('should stringify block if `modVal` filed is `undefined`', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         modName: 'mod',
         modVal: undefined
@@ -49,7 +50,7 @@ test('should stringify block if `modVal` filed is `undefined`', t => {
 });
 
 test('should stringify elem', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         elem: 'elem'
     });
@@ -58,7 +59,7 @@ test('should stringify elem', t => {
 });
 
 test('should stringify mod of elem', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         elem: 'elem',
         modName: 'mod',
@@ -69,7 +70,7 @@ test('should stringify mod of elem', t => {
 });
 
 test('should stringify boolean mod of elem', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         elem: 'elem',
         modName: 'mod'
@@ -79,7 +80,7 @@ test('should stringify boolean mod of elem', t => {
 });
 
 test('should stringify boolean mod of elem by strict notation', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         elem: 'elem',
         modName: 'mod',
@@ -90,7 +91,7 @@ test('should stringify boolean mod of elem by strict notation', t => {
 });
 
 test('should stringify elem if `modVal` filed is `undefined`', t => {
-    const str = naming.stringify({
+    const str = stringify({
         block: 'block',
         elem: 'elem',
         modName: 'mod',

test/presets/original/type-of.test.js

@@ -2,45 +2,46 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const typeOf = naming.typeOf;
 
 test('should not determine not valid string', t => {
-    const type = naming.typeOf('(*)_(*)');
+    const type = typeOf('(*)_(*)');
 
     t.is(type, undefined);
 });
 
 test('should determine block', t => {
-    const type = naming.typeOf('block');
+    const type = typeOf('block');
 
     t.is(type, 'block');
 });
 
 test('should determine mod of block', t => {
-    const type = naming.typeOf('block_mod_val');
+    const type = typeOf('block_mod_val');
 
     t.is(type, 'blockMod');
 });
 
 test('should determine boolean mod of block', t => {
-    const type = naming.typeOf('block_mod');
+    const type = typeOf('block_mod');
 
     t.is(type, 'blockMod');
 });
 
 test('should determine elem', t => {
-    const type = naming.typeOf('block__elem');
+    const type = typeOf('block__elem');
 
     t.is(type, 'elem');
 });
 
 test('should determine mod of elem', t => {
-    const type = naming.typeOf('block__elem_mod_val');
+    const type = typeOf('block__elem_mod_val');
 
     t.is(type, 'elemMod');
 });
 
 test('should determine boolean mod of elem', t => {
-    const type = naming.typeOf('block__elem_mod');
+    const type = typeOf('block__elem_mod');
 
     t.is(type, 'elemMod');
 });

test/presets/original/validate.test.js

@@ -2,63 +2,64 @@
 
 const test = require('ava');
 const naming = require('../../../index')('origin');
+const validate = naming.validate;
 
 test('should validate block', t => {
-    t.true(naming.validate('block'));
+    t.true(validate('block'));
 });
 
 test('should validate mod of block', t => {
-    t.true(naming.validate('block_mod_val'));
+    t.true(validate('block_mod_val'));
 });
 
 test('should validate boolean mod of block', t => {
-    t.true(naming.validate('block_mod'));
+    t.true(validate('block_mod'));
 });
 
 test('should validate elem', t => {
-    t.true(naming.validate('block__elem'));
+    t.true(validate('block__elem'));
 });
 
 test('should validate mod of elem', t => {
-    t.true(naming.validate('block__elem_mod_value'));
+    t.true(validate('block__elem_mod_value'));
 });
 
 test('should validate boolean mod of elem', t => {
-    t.true(naming.validate('block__elem_mod'));
+    t.true(validate('block__elem_mod'));
 });
 
 test('should not validate elem without block', t => {
-    t.false(naming.validate('__elem'));
+    t.false(validate('__elem'));
 });
 
 test('should not validate boolean mod without block', t => {
-    t.false(naming.validate('_mod'));
+    t.false(validate('_mod'));
 });
 
 test('should not validate mod without block', t => {
-    t.false(naming.validate('_mod_val'));
+    t.false(validate('_mod_val'));
 });
 
 test('should not validate mod of elem without block', t => {
-    t.false(naming.validate('__elem_mod_val'));
+    t.false(validate('__elem_mod_val'));
 });
 
 test('should not validate boolean mod of elem without block', t => {
-    t.false(naming.validate('__elem_mod'));
+    t.false(validate('__elem_mod'));
 });
 
 test('should not validate nested elem', t => {
-    t.false(naming.validate('block__elem1__elem2'));
+    t.false(validate('block__elem1__elem2'));
 });
 
 test('should not validate multi mod', t => {
-    t.false(naming.validate('block_mod_val__elem_mod_val'));
+    t.false(validate('block_mod_val__elem_mod_val'));
 });
 
 test('should not validate block name with illegal literals', t => {
-    t.false(naming.validate('^_^'));
+    t.false(validate('^_^'));
 });
 
 test('should support CamelCase', t => {
-    t.true(naming.validate('BlockName'));
+    t.true(validate('BlockName'));
 });