Merge pull request #71 from bem-sdk/belongs-to

feat: add belongsTo method

Author: skad0

README.md

@@ -67,6 +67,7 @@ API
 * [type](#type)
 * [isSimpleMod()](#issimplemod)
 * [isEqual(entityName)](#isequalentityname)
+* [belongsTo(entityName)](#belongstoentityname)
 * [toString()](#tostring)
 * [valueOf()](#valueof)
 * [toJSON()](#tojson)
@@ -227,6 +228,29 @@ inputName.isEqual(buttonName);  // false
 buttonName.isEqual(buttonName); // true
 ```
 
+### belongsTo(entityName)
+
+Parameter    | Type            | Description
+-------------|-----------------|-----------------------
+`entityName` | `BemEntityName` | The entity to compare.
+
+Determines whether specified entity belongs to this.
+
+```js
+const BemEntityName = require('@bem/entity-name');
+
+const buttonName = new BemEntityName({ block: 'button' });
+const buttonTextName = new BemEntityName({ block: 'button', elem: 'text' });
+const buttonTextBoldName = new BemEntityName(
+   { block: 'button', elem: 'text', mod: { name: 'bold', val: true } }
+);
+
+buttonTextName.belongsTo(buttonName);         // true
+buttonName.belongsTo(buttonTextName);         // false
+buttonTextBoldName.belongsTo(buttonTextName); // true
+buttonTextBoldName.belongsTo(buttonName);     // false
+```
+
 ### toString()
 
 Returns string representing the entity name.

index.js

@@ -310,6 +310,35 @@ class BemEntityName {
         return entityName && (this.id === entityName.id);
     }
 
+    /**
+     * Determines whether specified entity belongs to this.
+     *
+     * @example
+     * const BemEntityName = require('@bem/entity-name');
+     *
+     * const buttonName = new BemEntityName({ block: 'button' });
+     * const buttonTextName = new BemEntityName({ block: 'button', elem: 'text' });
+     * const buttonTextBoldName = new BemEntityName(
+     *    { block: 'button', elem: 'text', mod: { name: 'bold', val: true } }
+     * );
+     *
+     * buttonTextName.belongsTo(buttonName); // true
+     * buttonName.belongsTo(buttonTextName); // false
+     * buttonTextBoldName.belongsTo(buttonTextName); // true
+     * buttonTextBoldName.belongsTo(buttonName); // false
+     *
+     * @param {BemEntityName} entityName - the entity to compare.
+     *
+     * @returns {boolean}
+     */
+    belongsTo(entityName) {
+        return entityName && entityName.id !== this.id && this.id.startsWith(entityName.id) &&
+            (entityName.type !== 'block' || this.type !== 'elemMod') &&
+            (!entityName.elem || this.elem === entityName.elem) &&
+            (!entityName.modName || this.modName === entityName.modName) &&
+            (!entityName.modVal || entityName.modVal === true || this.modVal === entityName.modVal);
+    }
+
     /**
      * Determines whether specified entity is instance of BemEntityName.
      *

test/belongs-to.test.js

@@ -0,0 +1,123 @@
+const test = require('ava');
+
+const BemEntityName = require('../index');
+
+test('should not detect belonging between block and itself', t => {
+    const blockName = new BemEntityName({ block: 'block' });
+
+    t.false(blockName.belongsTo(blockName));
+});
+
+test('should not detect belonging between elem and itself', t => {
+    const elemName = new BemEntityName({ block: 'block', elem: 'elem' });
+
+    t.false(elemName.belongsTo(elemName));
+});
+
+test('should not detect belonging between block mod and itself', t => {
+    const modName = new BemEntityName({ block: 'block', mod: 'mod' });
+
+    t.false(modName.belongsTo(modName));
+});
+
+test('should not detect belonging between elem mod and itself', t => {
+    const modName = new BemEntityName({ block: 'block', elem: 'elem', mod: 'mod' });
+
+    t.false(modName.belongsTo(modName));
+});
+
+test('should resolve belonging between block and its elem', t => {
+    const blockName = new BemEntityName({ block: 'block' });
+    const elemName = new BemEntityName({ block: 'block', elem: 'elem' });
+
+    t.true(elemName.belongsTo(blockName));
+    t.false(blockName.belongsTo(elemName));
+});
+
+test('should not detect belonging between two block', t => {
+    const name1 = new BemEntityName({ block: 'block1' });
+    const name2 = new BemEntityName({ block: 'block2' });
+
+    t.false(name1.belongsTo(name2));
+    t.false(name2.belongsTo(name1));
+});
+
+test('should not detect belonging between two mods of block', t => {
+    const modName1 = new BemEntityName({ block: 'block', mod: 'mod1' });
+    const modName2 = new BemEntityName({ block: 'block', mod: 'mod2' });
+
+    t.false(modName1.belongsTo(modName2));
+    t.false(modName2.belongsTo(modName1));
+});
+
+test('should not detect belonging between two elems of block', t => {
+    const elemName1 = new BemEntityName({ block: 'block', elem: 'elem1' });
+    const elemName2 = new BemEntityName({ block: 'block', elem: 'elem2' });
+
+    t.false(elemName1.belongsTo(elemName2));
+    t.false(elemName2.belongsTo(elemName1));
+});
+
+test('should resolve belonging between block and its mod', t => {
+    const blockName = new BemEntityName({ block: 'block' });
+    const modName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'key' } });
+
+    t.true(modName.belongsTo(blockName));
+    t.false(blockName.belongsTo(modName));
+});
+
+test('should resolve belonging between elem and its mod', t => {
+    const elemName = new BemEntityName({ block: 'block', elem: 'elem' });
+    const modName = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: 'key' } });
+
+    t.true(modName.belongsTo(elemName));
+    t.false(elemName.belongsTo(modName));
+});
+
+test('should not detect belonging between block and its elem mod', t => {
+    const blockName = new BemEntityName({ block: 'block' });
+    const elemModName = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: 'key' } });
+
+    t.false(elemModName.belongsTo(blockName));
+    t.false(blockName.belongsTo(elemModName));
+});
+
+test('should not detect belonging between block and its elem with the same mod', t => {
+    const blockModName = new BemEntityName({ block: 'block', mod: 'mod' });
+    const elemModName = new BemEntityName({ block: 'block', elem: 'elem', mod: 'mod' });
+
+    t.false(elemModName.belongsTo(blockModName));
+    t.false(blockModName.belongsTo(elemModName));
+});
+
+test('should resolve belonging between boolean and key-value mod of block', t => {
+    const boolModName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: true } });
+    const modName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'key' } });
+
+    t.true(modName.belongsTo(boolModName));
+    t.false(boolModName.belongsTo(modName));
+});
+
+test('should resolve belonging between boolean and key-value mod of element', t => {
+    const boolModName = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: true } });
+    const modName = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: 'key' } });
+
+    t.true(modName.belongsTo(boolModName));
+    t.false(boolModName.belongsTo(modName));
+});
+
+test('should not detect belonging between key-value mods of block', t => {
+    const modName1 = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'key1' } });
+    const modName2 = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'key2' } });
+
+    t.false(modName1.belongsTo(modName2));
+    t.false(modName2.belongsTo(modName1));
+});
+
+test('should not detect belonging between key-value mods of elem', t => {
+    const modName1 = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: 'key1' } });
+    const modName2 = new BemEntityName({ block: 'block', elem: 'elem', mod: { name: 'mod', val: 'key2' } });
+
+    t.false(modName1.belongsTo(modName2));
+    t.false(modName2.belongsTo(modName1));
+});