[wip] Add convert for v1 format

1.js

@@ -0,0 +1,22 @@
+const no = require('./lib/normalize');
+console.log(JSON.stringify(
+    {
+        block: 'block',
+        elems: [
+            { elem: 'elem', mods: { m1:'v1' } },
+            { elem: 'elem2' },
+            { elem: 'elem', mods: { m2:'v2' } }
+        ]
+    }, null, 4
+));
+console.log('===========');
+console.log(no([
+    {
+        block: 'block',
+        elems: [
+            { elem: 'elem', mods: { m1:'v1' } },
+            { elem: 'elem2' },
+            { elem: 'elem', mods: { m2:'v2' } }
+        ]
+    }
+], { format: 'v2' }));

lib/convert/enb.js → lib/format/enb.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * Convert normalized declaration to enb format
+ * Formats normalized declaration to enb format
  *
  * @param  {Array|Object} decl Source declaration
  * @return {Array}

lib/convert.js → lib/format/index.js

@@ -8,20 +8,20 @@ const isNotSupported = () => {
     );
 };
 
-const converters = {
-    enb: require('./convert/enb'),
+const formatters = {
+    enb: require('./enb'),
     v2: isNotSupported,
-    v1: isNotSupported,
+    v1: require('./v1'),
     harmony: isNotSupported
 };
 
 /**
- * Convert normalized declaration to target format
+ * Formats normalized declaration to target format
  *
  * @param  {Array|Object} decl normalized declaration
  * @param  {Object}       opts Addtional options
  * @param  {String}       opts.format format format
- * @return {Array}        Array with converted declaration
+ * @return {Array}        Array with formatted declaration
  */
 module.exports = function (decl, opts) {
     opts || (opts = {});
@@ -30,9 +30,9 @@ module.exports = function (decl, opts) {
 
     assert(format, 'You must declare target format');
 
-    if (!converters[format]) {
+    if (!formatters[format]) {
         throw new Error('Unknown format');
     }
 
-    return converters[format](decl);
+    return formatters[format](decl);
 };

lib/format/v1.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Formats normalized declaration to v1 format
+ *
+ * @param  {Array|Object} decl Source declaration
+ * @return {Array}
+ */
+module.exports = function (decl) {
+    Array.isArray(decl) || (decl = [decl]);
+
+    // previous block in declaration
+    let prevBlock = '';
+
+    return !decl.length ? [] : decl.reduce((acc, dep) => {
+        const canGroup = dep.entity.block === prevBlock;
+        const entity = dep.entity;
+        const item = { name: entity[entity.elem ? 'elem' : 'block'] };
+
+        if (entity.modName) {
+            item.mods = [{
+                name: entity.modName,
+                vals: [entity.modVal]
+            }];
+        }
+
+        const result = entity.elem ? { name: entity.block, elems: [item] } : item;
+
+        if (result.elems && entity.elem) {
+            // If exists block
+            const curBlock = acc.find(
+                curEntity => curEntity.name === entity.block
+            );
+
+            if (curBlock && canGroup) {
+                if (curBlock.elems) {
+                    // check if elem exists
+                    const curElem = curBlock.elems.find(elem => elem.name === entity.elem);
+                    curElem || curBlock.elems.push(result.elems[0]);
+                } else {
+                    curBlock.elems = result.elems;
+                }
+            } else {
+                acc.push(result);
+            }
+
+            // If such element already exists and we have mod
+            const modsAddition = acc.find(curEntity => {
+                const curElem = curEntity.elems ?
+                    curEntity.elems.find(elem => elem.name === entity.elem) : false;
+                return curEntity.name === entity.block && curElem;
+            });
+
+            if (entity.modName) {
+                const curElem = modsAddition.elems.find(elem => elem.name === entity.elem);
+                if (curElem.mods) {
+                    // have an array of mods in elem
+                    // check if such mod already exists
+                    const curMod = curElem.mods.find(
+                        mod => mod.name === entity.modName
+                    );
+                    if (curMod) {
+                        // check if val already exists
+                        const curVal = curMod.vals.find(val =>
+                            val === entity.modVal
+                        );
+
+                        curVal || curMod.vals.push(result.elems[0].mods[0].vals[0]);
+                    } else {
+                        // add new mod
+                        curElem.mods.push(result.elems[0].mods[0]);
+                    }
+                }
+            }
+        } else if (entity.modName) {
+            const curBlock = acc.find(curEntity => curEntity.name === entity.block);
+            // if block with mods prop exists search for such mod
+            if (curBlock && canGroup) {
+                if (curBlock.mods) {
+                    const curMod = curBlock.mods.find(mod => mod.name === entity.modName);
+                    if (curMod) {
+                        // if such mod exists push new val
+                        curMod.vals.push(result.mods[0].vals[0]);
+                    } else {
+                        // if no such mod push new mod
+                        curBlock.mods.push(result.mods[0]);
+                    }
+                } else {
+                    curBlock.mods = result.mods;
+                }
+            } else {
+                acc.push(result);
+            }
+        } else {
+            acc.push(result);
+        }
+        // save previous block
+        prevBlock = dep.entity.block;
+
+        return acc;
+    }, []);
+};

lib/normalize.js → lib/normalize/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
 const normalizer = {
-    v1: require('./normalize/v1'),
-    v2: require('./normalize/v2'),
-    harmony: require('./normalize/harmony'),
-    enb: require('./normalize/v2')
+    v1: require('./v1'),
+    v2: require('./v2'),
+    harmony: require('./harmony'),
+    enb: require('./v2')
 };
 
 module.exports = (decl, opts) => {

lib/stringify.js

@@ -2,7 +2,7 @@
 
 const assert = require('assert');
 
-const convert = require('./convert');
+const formatter = require('./format');
 
 /**
  * Create string representation of declaration
@@ -20,8 +20,8 @@ module.exports = function (decl, opts) {
 
     Array.isArray(decl) || (decl = [decl]);
 
-    const formatedDecl = convert(decl, { format });
-    const jsonStr = JSON.stringify(formatedDecl, null, 4);
+    const formattedDecl = formatter(decl, { format });
+    const jsonStr = JSON.stringify(formattedDecl, null, 4);
 
     let exportsStr = '';
 

test/convert/enb.test.js → test/format/enb.test.js

@@ -2,19 +2,19 @@
 
 const test = require('ava');
 
-const convert = require('../../lib/convert');
+const format = require('../../lib/format');
 
 test('should throw exception if no format given', t => {
-    t.throws(() => convert({ entity: { block: 'block' }, tech: null }), 'You must declare target format');
+    t.throws(() => format({ entity: { block: 'block' }, tech: null }), 'You must declare target format');
 });
 
-test('should convert to enb format', t => {
-    t.deepEqual(convert({ entity: { block: 'block' }, tech: null }, { format: 'enb' }), [{ block: 'block' }]);
+test('should format to enb format', t => {
+    t.deepEqual(format({ entity: { block: 'block' }, tech: null }, { format: 'enb' }), [{ block: 'block' }]);
 });
 
-test('should convert with elem', t => {
+test('should format with elem', t => {
     t.deepEqual(
-        convert([
+        format([
             { entity: { block: 'block' }, tech: null },
             { entity: { block: 'block', elem: 'elem' }, tech: null }
         ], { format: 'enb' }),
@@ -25,9 +25,9 @@ test('should convert with elem', t => {
     );
 });
 
-test('should convert with mod', t => {
+test('should format with mod', t => {
     t.deepEqual(
-        convert([
+        format([
             { entity: { block: 'block', modName: 'mod', modVal: 'val' }, tech: null }
         ], { format: 'enb' }),
         [{ block: 'block', mod: 'mod', val: 'val' }]