Apply recommended ESLint rules

Getting rid of unused arguments, etc.

Author: fatfisz

.eslintrc.js

@@ -2,22 +2,43 @@
 
 module.exports = {
   root: true,
-  extends: ['plugin:prettier/recommended'],
+  extends: ['eslint:recommended', 'plugin:prettier/recommended'],
   parserOptions: {
-    ecmaVersion: 2017,
+    ecmaVersion: 2018,
     sourceType: 'module',
   },
   parser: 'babel-eslint',
 
+  globals: {
+    console: true,
+  },
+
   rules: {
     strict: [2, 'global'],
+
+    'no-param-reassign': 2,
   },
 
-  overrides: {
-    files: ['.babelrc.js', '.eslintrc.js', 'jest.config.js'],
+  overrides: [
+    {
+      files: ['.babelrc.js', '.eslintrc.js', 'jest.config.js'],
+
+      parserOptions: {
+        sourceType: 'script',
+      },
 
-    parserOptions: {
-      sourceType: 'script',
+      env: {
+        node: true,
+      },
     },
-  },
+    {
+      files: '*.test.js',
+
+      env: {
+        es6: true,
+        jest: true,
+        node: true,
+      },
+    },
+  ],
 };

src/TemplateTag/TemplateTag.js

@@ -15,6 +15,7 @@ export default class TemplateTag {
    */
   constructor(...transformers) {
     if (!deprecationWarningPrinted) {
+      // eslint-disable-next-line no-console
       console.warn(
         'TemplateTag is deprecated and will be removed in the next major version. Use createTag instead.',
       );

src/TemplateTag/TemplateTag.test.js

@@ -1,5 +1,7 @@
 import TemplateTag from '../TemplateTag';
 
+/* eslint-disable no-console */
+
 beforeEach(() => {
   console.warn = jest.fn();
 });
@@ -19,6 +21,8 @@ test('a warning should be printed the first time a TemplateTag is constructed',
   expect(console.warn).toHaveBeenCalledTimes(1);
 });
 
+/* eslint-enable no-console */
+
 test('performs a transformation & provides correct values to transform methods', () => {
   const tag = new TemplateTag({
     onString(str) {

src/inlineArrayTransformer/inlineArrayTransformer.js

@@ -1,9 +1,3 @@
-const defaults = {
-  separator: '',
-  conjunction: '',
-  serial: false,
-};
-
 /**
  * Converts an array substitution to a string containing a list
  * @param  {String} [opts.separator = ''] - the character that separates each item
@@ -12,34 +6,31 @@ const defaults = {
  *
  * @return {Object}                     - a TemplateTag transformer
  */
-const inlineArrayTransformer = (opts = defaults) => ({
+const inlineArrayTransformer = ({
+  conjunction = '',
+  separator = '',
+  serial = false,
+} = {}) => ({
   onSubstitution(substitution, resultSoFar) {
     // only operate on arrays
-    if (Array.isArray(substitution)) {
-      const arrayLength = substitution.length;
-      const separator = opts.separator;
-      const conjunction = opts.conjunction;
-      const serial = opts.serial;
-      // join each item in the array into a string where each item is separated by separator
-      // be sure to maintain indentation
-      const indent = resultSoFar.match(/(\n?[^\S\n]+)$/);
-      if (indent) {
-        substitution = substitution.join(separator + indent[1]);
-      } else {
-        substitution = substitution.join(separator + ' ');
-      }
-      // if conjunction is set, replace the last separator with conjunction, but only if there is more than one substitution
-      if (conjunction && arrayLength > 1) {
-        const separatorIndex = substitution.lastIndexOf(separator);
-        substitution =
-          substitution.slice(0, separatorIndex) +
-          (serial ? separator : '') +
-          ' ' +
-          conjunction +
-          substitution.slice(separatorIndex + 1);
-      }
+    if (!Array.isArray(substitution)) {
+      return substitution;
     }
-    return substitution;
+
+    // be sure to maintain indentation
+    const indent = resultSoFar.match(/(\n?[^\S\n]+)$/);
+    const fullSeparator = separator.concat(indent ? indent[1] : ' ');
+    const fullConjunction = ''.concat(conjunction, ' ');
+    const conjunctionIndex = conjunction ? substitution.length - 1 : -1;
+
+    return substitution.reduce((result, part, index) =>
+      ''.concat(
+        result,
+        index !== conjunctionIndex || serial ? fullSeparator : ' ',
+        index === conjunctionIndex ? fullConjunction : '',
+        part,
+      ),
+    );
   },
 });
 

src/inlineArrayTransformer/inlineArrayTransformer.test.js

@@ -22,6 +22,15 @@ test('replaces last separator with a conjunction', () => {
   );
 });
 
+test('replaces last separator with a conjunction', () => {
+  const tag = createTag(
+    inlineArrayTransformer({ separator: ',', conjunction: 'and' }),
+  );
+  expect(
+    tag`I like ${['apple', 'banana', 'a fruit that has "," in the name']}`,
+  ).toBe('I like apple, banana and a fruit that has "," in the name');
+});
+
 test('does not use a conjunction if there is only one item in an array', () => {
   const tag = createTag(
     inlineArrayTransformer({ separator: ',', conjunction: 'and' }),

src/replaceSubstitutionTransformer/replaceSubstitutionTransformer.js

@@ -1,5 +1,5 @@
 const replaceSubstitutionTransformer = (replaceWhat, replaceWith) => ({
-  onSubstitution(substitution, resultSoFar) {
+  onSubstitution(substitution) {
     if (replaceWhat == null || replaceWith == null) {
       throw new Error(
         'replaceSubstitutionTransformer requires at least 2 arguments.',

src/splitStringTransformer/splitStringTransformer.js

@@ -1,14 +1,16 @@
-const splitStringTransformer = splitBy => ({
-  onSubstitution(substitution, resultSoFar) {
-    if (splitBy != null && typeof splitBy === 'string') {
+const splitStringTransformer = splitBy => {
+  if (typeof splitBy !== 'string') {
+    throw new Error('You need to specify a string character to split by.');
+  }
+
+  return {
+    onSubstitution(substitution) {
       if (typeof substitution === 'string' && substitution.includes(splitBy)) {
-        substitution = substitution.split(splitBy);
+        return substitution.split(splitBy);
       }
-    } else {
-      throw new Error('You need to specify a string character to split by.');
-    }
-    return substitution;
-  },
-});
+      return substitution;
+    },
+  };
+};
 
 export default splitStringTransformer;

src/splitStringTransformer/splitStringTransformer.test.js

@@ -17,9 +17,14 @@ test('ignores substitution if it is not a string', () => {
   expect(tag`foo ${5}`).toBe('foo 5');
 });
 
-test('throws an error if splitBy param is undefined or not a string', () => {
-  const tag1 = createTag(splitStringTransformer());
-  const tag2 = createTag(splitStringTransformer(5));
-  expect(() => tag1`foo ${'bar'}`).toThrow();
-  expect(() => tag2`foo ${'bar'}`).toThrow();
+test('throws an error if splitBy param is undefined', () => {
+  expect(() => {
+    splitStringTransformer();
+  }).toThrow(/specify a string character to split by/);
+});
+
+test('throws an error if splitBy param is not a string', () => {
+  expect(() => {
+    splitStringTransformer(42);
+  }).toThrow(/specify a string character to split by/);
 });

src/trimResultTransformer/trimResultTransformer.js

@@ -1,26 +1,31 @@
+const supportedSides = ['', 'start', 'left', 'end', 'right'];
+
 /**
  * TemplateTag transformer that trims whitespace on the end result of a tagged template
  * @param  {String} side = '' - The side of the string to trim. Can be 'start' or 'end' (alternatively 'left' or 'right')
  * @return {Object}           - a TemplateTag transformer
  */
-const trimResultTransformer = (side = '') => ({
-  onEndResult(endResult) {
-    if (side === '') {
-      return endResult.trim();
-    }
-
-    side = side.toLowerCase();
+const trimResultTransformer = (side = '') => {
+  if (!supportedSides.includes(side)) {
+    throw new Error(`Side not supported: ${side}`);
+  }
 
-    if (side === 'start' || side === 'left') {
-      return endResult.replace(/^\s*/, '');
-    }
+  return {
+    onEndResult(endResult) {
+      switch (side) {
+        case '':
+          return endResult.trim();
 
-    if (side === 'end' || side === 'right') {
-      return endResult.replace(/\s*$/, '');
-    }
+        case 'start':
+        case 'left':
+          return endResult.replace(/^\s*/, '');
 
-    throw new Error(`Side not supported: ${side}`);
-  },
-});
+        case 'end':
+        case 'right':
+          return endResult.replace(/\s*$/, '');
+      }
+    },
+  };
+};
 
 export default trimResultTransformer;

src/trimResultTransformer/trimResultTransformer.test.js

@@ -27,11 +27,6 @@ test('trims right padding', () => {
   expect(trimRight`  foo  `).toBe('  foo');
 });
 
-test('throws an error if invalid side supplied', () => {
-  const trimUp = createTag(trimResultTransformer('up'));
-  expect(() => trimUp`foo`).toThrow();
-});
-
 test('can be used sequentially', () => {
   const trimStart = createTag(
     stripIndentTransformer(),
@@ -40,3 +35,9 @@ test('can be used sequentially', () => {
   expect(trimStart`  foo  `).toBe('foo  ');
   expect(trimStart`  bar  `).toBe('bar  ');
 });
+
+test('throws an error if invalid side supplied', () => {
+  expect(() => {
+    trimResultTransformer('up');
+  }).toThrow(/not supported/);
+});