Update bem-naming to support react naming scheme (close #30). (#39)

Update bem-fs-scheme (close #31).

.eslintignore

@@ -0,0 +1 @@
+test/tmp/

README.ru.md

@@ -337,8 +337,10 @@ module.exports = {
 
             // Смотри https://ru.bem.info/toolbox/sdk/bem-naming/#Собственный-стиль
             naming: {
-                elem: '-',
-                mod: { name: '--', val: '_' },
+                delims: {
+                    elem: '-',
+                    mod: { name: '--', val: '_' }
+                },
                 wordPattern: '[a-zA-Z0-9]+'
             }
         }
@@ -424,8 +426,10 @@ module.exports = {
 
             // Смотри https://ru.bem.info/toolbox/sdk/bem-naming/#Собственный-стиль
             naming: {
-                elem: '-',
-                mod: { name: '--', val: '_' },
+                delims: {
+                    elem: '-',
+                    mod: { name: '--', val: '_' }
+                },
                 wordPattern: '[a-zA-Z0-9]+'
             }
         }

lib/create-entity.js

@@ -2,10 +2,11 @@
 
 var fs = require('fs'),
     path = require('path'),
-    bemNaming = require('bem-naming'),
+    bemNaming = require('@bem/naming'),
     Promise = require('pinkie-promise'),
     mkdirp = require('mkdirp'),
-    createTree = require('./create-tree');
+    createTree = require('./create-tree'),
+    relativePath = function(to) { return path.relative(process.cwd(), to); };
 
 module.exports = function(entity, fileName, template, options) {
     return new Promise(function(resolve, reject) {
@@ -14,7 +15,7 @@ module.exports = function(entity, fileName, template, options) {
 
         fs.exists(fileName, function(exists) {
             if (isFile && exists) {
-                options.noWarn || console.log('File ' + fileName + ' already exists.');
+                options.noWarn || console.log('File ' + relativePath(fileName) + ' already exists.');
                 return resolve(fileName);
             }
 

lib/create-tree.js

@@ -3,7 +3,8 @@
 var fs = require('fs'),
     path = require('path'),
     mkdirp = require('mkdirp'),
-    Promise = require('pinkie-promise');
+    Promise = require('pinkie-promise'),
+    relativePath = function(to) { return path.relative(process.cwd(), to); };
 
 function walk(tree, root, options) {
     return new Promise(function(rslv, rjct) {
@@ -23,7 +24,7 @@ function walk(tree, root, options) {
 
                     fs.exists(pathToFile, function(exists) {
                         if (exists) {
-                            options.noWarn || console.log('File ' + pathToFile + ' already exists.');
+                            options.noWarn || console.log('File ' + relativePath(pathToFile) + ' already exists.');
                             return resolve(file);
                         }
 

lib/create.js

@@ -2,8 +2,10 @@
 
 var path = require('path'),
     bemConfig = require('bem-config'),
-    scheme = require('bem-fs-scheme'),
-    bemNaming = require('bem-naming'),
+    BemEntityName = require('@bem/entity-name'),
+    BemCell = require('@bem/cell'),
+    scheme = require('@bem/fs-scheme'),
+    bemNaming = require('@bem/naming'),
     braceExpansion = require('brace-expansion'),
     createEntity = require('./create-entity'),
     getTemplate = require('./template'),
@@ -56,10 +58,8 @@ module.exports = function create(entities, levels, techs, options) {
                         return config.level(level).then(function(levelOptions) {
                             levelOptions || (levelOptions = {});
 
-                            var namingOpts = levelOptions.naming,
-                                levelScheme = levelOptions.scheme,
+                            var levelScheme = levelOptions.scheme,
                                 buildPath = scheme(levelScheme).path,
-                                entity = filepathOrInput,
 
                                 pluginConfLevels = Object.keys(pluginConf.levels || {})
                                     .reduce(function(acc, relPluginConfLevel) {
@@ -73,16 +73,20 @@ module.exports = function create(entities, levels, techs, options) {
 
                                 pluginTechs = pluginConf.techs || [],
                                 currentTechs = uniq([].concat(pluginConfLevelTechs || pluginTechs, techs)),
-                                templatesOpts = Object.assign({}, pluginConf, pluginConfLevel);
+                                templatesOpts = Object.assign({}, pluginConf, pluginConfLevel),
+                                entity;
 
                             if (isFileGlob) {
                                 var file = path.basename(filepathOrInput),
-                                    splitted = file.split('.');
+                                    // split for entity key and tech (by first dot)
+                                    match = file.match(/^([^.]+)(?:\.(.+))?$/);
 
-                                entity = bemNaming(namingOpts).parse(splitted.shift());
-                                if (splitted.join('.')) {
-                                    currentTechs = uniq(techs.concat(splitted.join('.')));
+                                entity = bemNaming(levelOptions.naming).parse(match[1]);
+                                if (match[2]) {
+                                    currentTechs = uniq(techs.concat(match[2]));
                                 }
+                            } else {
+                                entity = BemEntityName.create(filepathOrInput);
                             }
 
                             options.onlyTech && (currentTechs = options.onlyTech);
@@ -92,11 +96,13 @@ module.exports = function create(entities, levels, techs, options) {
                             }));
 
                             return Promise.all(currentTechs.map(function(tech) {
-                                var pathToFile = buildPath(entity, tech, { naming: namingOpts }),
+                                var pathToFile = buildPath(
+                                        new BemCell({ entity: entity, tech: tech }),
+                                        levelOptions),
                                     absPathToFile = path.join(path.resolve(level), pathToFile),
                                     template = getTemplate(tech, templatesOpts);
 
-                                return createEntity(entity, absPathToFile, template, { naming: namingOpts });
+                                return createEntity(entity, absPathToFile, template, levelOptions);
                             }));
                         });
                     });

package.json

@@ -17,9 +17,11 @@
   "author": "",
   "license": "MPL-2.0",
   "dependencies": {
+    "@bem/cell": "^0.2.5",
+    "@bem/entity-name": "^1.3.2",
+    "@bem/fs-scheme": "^2.1.0",
+    "@bem/naming": "^2.0.0",
     "bem-config": "^3.1.0",
-    "bem-fs-scheme": "^1.0.0",
-    "bem-naming": "^1.0.1",
     "brace-expansion": "^1.1.6",
     "mkdirp": "^0.5.1",
     "pinkie-promise": "^2.0.1",

test/test.js

@@ -5,8 +5,9 @@ const path = require('path');
 const mkdirp = require('mkdirp');
 const rimraf = require('rimraf');
 const create = require('..');
-const naming = require('bem-naming');
+const naming = require('@bem/naming');
 const EOL = require('os').EOL;
+const assert = require('assert');
 
 const tmpDir = path.join(__dirname, 'tmp');
 const initialCwd = process.cwd();
@@ -29,9 +30,10 @@ function testEntityHelper(entities, levels, techs, options, expected) {
         expected.forEach(file => {
             let actualContent;
             const createdIndex = created.indexOf(file.name);
+            const relativeFileName = path.relative(initialCwd, file.name);
 
             if (createdIndex === -1) {
-                throw new Error(`There is no ${file.name} in result returned`);
+                throw new Error(`There is no ${relativeFileName} in result returned`);
             }
 
             if (typeof file.content === 'undefined') {
@@ -41,12 +43,10 @@ function testEntityHelper(entities, levels, techs, options, expected) {
             try {
                 actualContent = fs.readFileSync(file.name, 'utf8');
             } catch (err) {
-                throw new Error(`${file.name} was not created`);
+                throw new Error(`${relativeFileName} was not created`);
             }
 
-            if (actualContent !== file.content) {
-                throw new Error(`${file.name} content is not correct`);
-            }
+            assert.equal(actualContent, file.content, `${relativeFileName} content is not correct`);
 
             created.splice(createdIndex, 1);
         });
@@ -113,8 +113,10 @@ describe('bem-tools-create', () => {
         it('should create entities with naming from config', () => {
             const entity = { block: 'b', elem: 'e1', modName: 'm1', modVal: 'v1' };
             const namingScheme = {
-                elem: '-',
-                mod: { name: '--', val: '_' }
+                delims: {
+                    elem: '-',
+                    mod: { name: '--', val: '_' }
+                }
             };
 
             return testEntityHelper([entity], [tmpDir], ['css'], { defaults: { naming: namingScheme } }, [{
@@ -161,8 +163,10 @@ describe('bem-tools-create', () => {
                 const levels = [path.join(tmpDir, 'l1'), path.join(tmpDir, 'l2')];
                 const entity = { block: 'b', elem: 'e1', modName: 'm1', modVal: 'v1' };
                 const namingScheme = {
-                    elem: '-',
-                    mod: { name: '--', val: '_' }
+                    delims: {
+                        elem: '-',
+                        mod: { name: '--', val: '_' }
+                    }
                 };
                 const opts = {
                     defaults: {