Prevent diff

Author: armandabric

src/formatter/formatProp.spec.ts

@@ -79,6 +79,7 @@ describe('formatProp', () => {
       useBooleanShorthandSyntax: true,
       tabStop: 2,
     };
+
     formatPropValue.mockReturnValue('{true}');
 
     expect(
@@ -98,6 +99,7 @@ describe('formatProp', () => {
       useBooleanShorthandSyntax: true,
       tabStop: 2,
     };
+
     formatPropValue.mockReturnValue('{false}');
 
     expect(
@@ -116,6 +118,7 @@ describe('formatProp', () => {
       useBooleanShorthandSyntax: false,
       tabStop: 2,
     };
+
     formatPropValue.mockReturnValue('{true}');
 
     expect(
@@ -135,6 +138,7 @@ describe('formatProp', () => {
       useBooleanShorthandSyntax: false,
       tabStop: 2,
     };
+
     formatPropValue.mockReturnValue('{false}');
 
     expect(
@@ -198,6 +202,7 @@ describe('formatProp', () => {
       useBooleanShorthandSyntax: true,
       tabStop: 2,
     };
+
     formatPropValue.mockReturnValue('"MockedPropValue"');
 
     expect(

src/formatter/formatProp.ts

@@ -1,6 +1,7 @@
 import spacer from './spacer';
 import formatPropValue from './formatPropValue';
 import type { Options } from './../options';
+
 export default (
   name: string,
   hasValue: boolean,
@@ -22,8 +23,11 @@ export default (
   }
 
   const usedValue = hasValue ? value : defaultValue;
+
   const { useBooleanShorthandSyntax, tabStop } = options;
+
   const formattedPropValue = formatPropValue(usedValue, inline, lvl, options);
+
   let attributeFormattedInline = ' ';
   let attributeFormattedMultiline = `\n${spacer(lvl + 1, tabStop)}`;
   const isMultilineAttribute = formattedPropValue.includes('\n');

src/formatter/formatPropValue.spec.tsx

@@ -3,39 +3,48 @@ import formatPropValue from './formatPropValue';
 import parseReactElement from './../parser/parseReactElement';
 import formatTreeNode from './formatTreeNode';
 import formatComplexDataStructure from './formatComplexDataStructure';
+
 jest.mock('./../parser/parseReactElement');
+
 jest.mock('./formatTreeNode', () =>
   jest.fn().mockReturnValue('<MockedFormatTreeNodeResult />')
 );
+
 jest.mock('./formatComplexDataStructure', () =>
   jest.fn().mockReturnValue('*Mocked formatComplexDataStructure result*')
 );
+
 describe('formatPropValue', () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
+
   it('should format an integer prop value', () => {
     expect(formatPropValue(42, false, 0, {})).toBe('{42}');
   });
+
   it('should escape double quote on prop value of string type', () => {
     expect(formatPropValue('Hello "Jonh"!', false, 0, {})).toBe(
       '"Hello &quot;Jonh&quot;!"'
     );
   });
+
   it('should format a symbol prop value', () => {
     expect(formatPropValue(Symbol('Foo'), false, 0, {})).toBe(
       "{Symbol('Foo')}"
     );
     // eslint-disable-next-line symbol-description
     expect(formatPropValue(Symbol(), false, 0, {})).toBe('{Symbol()}');
   });
+
   it('should replace a function prop value by a an empty generic function by default', () => {
     const doThings = (a) => a * 2;
 
     expect(formatPropValue(doThings, false, 0, {})).toBe(
       '{function noRefCheck() {}}'
     );
   });
+
   it('should show the function prop value implementation if "showFunctions" option is true', () => {
     const doThings = (a) => a * 2;
 
@@ -45,11 +54,13 @@ describe('formatPropValue', () => {
       })
     ).toBe('{function doThings(a) {return a * 2;}}');
   });
+
   it('should format the function prop value with the "functionValue" option', () => {
     const doThings = (a) => a * 2;
 
     const functionValue = (fn) => {
       expect(fn).toBe(doThings);
+
       return 'function Myfunction() {}';
     };
 
@@ -66,23 +77,27 @@ describe('formatPropValue', () => {
       })
     ).toBe('{function Myfunction() {}}');
   });
+
   it('should parse and format a react element prop value', () => {
     expect(formatPropValue(<div />, false, 0, {})).toBe(
       '{<MockedFormatTreeNodeResult />}'
     );
     expect(parseReactElement).toHaveBeenCalledTimes(1);
     expect(formatTreeNode).toHaveBeenCalledTimes(1);
   });
+
   it('should format a date prop value', () => {
     expect(
       formatPropValue(new Date('2017-01-01T11:00:00.000Z'), false, 0, {})
     ).toBe('{new Date("2017-01-01T11:00:00.000Z")}');
   });
+
   it('should format an invalid date prop value', () => {
     expect(formatPropValue(new Date(NaN), false, 0, {})).toBe(
       '{new Date(NaN)}'
     );
   });
+
   it('should format an object prop value', () => {
     expect(
       formatPropValue(
@@ -96,22 +111,27 @@ describe('formatPropValue', () => {
     ).toBe('{*Mocked formatComplexDataStructure result*}');
     expect(formatComplexDataStructure).toHaveBeenCalledTimes(1);
   });
+
   it('should format an array prop value', () => {
     expect(formatPropValue(['a', 'b', 'c'], false, 0, {})).toBe(
       '{*Mocked formatComplexDataStructure result*}'
     );
     expect(formatComplexDataStructure).toHaveBeenCalledTimes(1);
   });
+
   it('should format a boolean prop value', () => {
     expect(formatPropValue(true, false, 0, {})).toBe('{true}');
     expect(formatPropValue(false, false, 0, {})).toBe('{false}');
   });
+
   it('should format null prop value', () => {
     expect(formatPropValue(null, false, 0, {})).toBe('{null}');
   });
+
   it('should format undefined prop value', () => {
     expect(formatPropValue(undefined, false, 0, {})).toBe('{undefined}');
   });
+
   it('should call the ".toString()" method on object instance prop value', () => {
     expect(formatPropValue(new Set(['a', 'b', 42]), false, 0, {})).toBe(
       '{[object Set]}'

src/formatter/formatReactElementNode.spec.tsx

@@ -1,5 +1,6 @@
 import React from 'react';
 import formatReactElementNode from './formatReactElementNode';
+
 const defaultOptions = {
   filterProps: [],
   showDefaultProps: true,
@@ -8,6 +9,7 @@ const defaultOptions = {
   useBooleanShorthandSyntax: true,
   sortProps: true,
 };
+
 describe('formatReactElementNode', () => {
   it('should format a react element with a string a children', () => {
     const tree = {
@@ -22,10 +24,12 @@ describe('formatReactElementNode', () => {
         },
       ],
     };
+
     expect(formatReactElementNode(tree, false, 0, defaultOptions)).toEqual(`<h1>
   Hello world
 </h1>`);
   });
+
   it('should format a single depth react element', () => {
     const tree = {
       type: 'ReactElement',
@@ -38,10 +42,12 @@ describe('formatReactElementNode', () => {
       },
       childrens: [],
     };
+
     expect(formatReactElementNode(tree, false, 0, defaultOptions)).toEqual(
       '<aaa foo="41" />'
     );
   });
+
   it('should format a react element with an object as props', () => {
     const tree = {
       type: 'ReactElement',
@@ -64,6 +70,7 @@ describe('formatReactElementNode', () => {
       },
       childrens: [],
     };
+
     expect(formatReactElementNode(tree, false, 0, defaultOptions)).toEqual(`<div
   a={{
     aa: '1',
@@ -73,6 +80,7 @@ describe('formatReactElementNode', () => {
   }}
  />`);
   });
+
   it('should format a react element with another react element as props', () => {
     const tree = {
       type: 'ReactElement',
@@ -85,10 +93,12 @@ describe('formatReactElementNode', () => {
       },
       childrens: [],
     };
+
     expect(formatReactElementNode(tree, false, 0, defaultOptions)).toEqual(
       '<div a={<span b="42" />} />'
     );
   });
+
   it('should format a react element with multiline children', () => {
     const tree = {
       type: 'ReactElement',
@@ -102,19 +112,22 @@ describe('formatReactElementNode', () => {
         },
       ],
     };
+
     expect(formatReactElementNode(tree, false, 0, defaultOptions))
       .toEqual(`<div>
   first line
   second line
   third line
 </div>`);
+
     expect(formatReactElementNode(tree, false, 2, defaultOptions))
       .toEqual(`<div>
       first line
       second line
       third line
     </div>`);
   });
+
   it('should allow filtering props by function', () => {
     const tree = {
       type: 'ReactElement',
@@ -135,6 +148,7 @@ describe('formatReactElementNode', () => {
       ...defaultOptions,
       filterProps: (val, key) => !key.startsWith('on'),
     };
+
     expect(formatReactElementNode(tree, false, 0, options))
       .toEqual(`<h1 className="myClass">
   Hello world

src/formatter/formatReactElementNode.ts

@@ -119,20 +119,26 @@ export default (
   let outInlineAttr = out;
   let outMultilineAttr = out;
   let containsMultilineAttr = false;
+
   const visibleAttributeNames: Array<string> = [];
+
   const propFilter = createPropFilter(props, filterProps);
+
   Object.keys(props)
     .filter(propFilter)
     .filter(onlyPropsWithOriginalValue(defaultProps, props))
     .forEach((propName) => visibleAttributeNames.push(propName));
+
   Object.keys(defaultProps)
     .filter(propFilter)
     .filter(() => showDefaultProps)
     .filter(
       (defaultPropName) => !visibleAttributeNames.includes(defaultPropName)
     )
     .forEach((defaultPropName) => visibleAttributeNames.push(defaultPropName));
+
   const attributes = sortPropsByNames(sortProps)(visibleAttributeNames);
+
   attributes.forEach((attributeName) => {
     const {
       attributeFormattedInline,
@@ -156,6 +162,7 @@ export default (
     outInlineAttr += attributeFormattedInline;
     outMultilineAttr += attributeFormattedMultiline;
   });
+
   outMultilineAttr += `\n${spacer(lvl, tabStop)}`;
 
   if (
@@ -176,6 +183,7 @@ export default (
 
   if (childrens && childrens.length > 0) {
     const newLvl = lvl + 1;
+
     out += '>';
 
     if (!inline) {