Merge pull request #193 from pplancq/feature/eslint

.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*]
+end_of_line = lf

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

examples/ecmascript/specs/step-definitions/auto-step-binding.steps.js

@@ -1,28 +1,29 @@
-import { loadFeatures, autoBindSteps } from 'jest-cucumber';
-import { VendingMachine } from '../../src/vending-machine';
-
-export const vendingMachineSteps = ({ given, and, when, then }) => {
-    let vendingMachine;
-
-    given(/^the vending machine has "(.*)" in stock$/, (itemName) => {
-        vendingMachine = new VendingMachine();
-        vendingMachine.stockItem(itemName, 1);
-    });
-
-    and('I have inserted the correct amount of money', () => {
-        vendingMachine.insertMoney(0.50);
-    });
-
-    when(/^I purchase "(.*)"$/, (itemName) => {
-        vendingMachine.dispenseItem(itemName);
-    });
-
-    then(/^my "(.*)" should be dispensed$/, (itemName) => {
-        const inventoryAmount = vendingMachine.items[itemName];
-        expect(inventoryAmount).toBe(0);
-    });
-};
-
-const features = loadFeatures('./specs/features/auto-binding/**/*.feature');
-
-autoBindSteps(features, [ vendingMachineSteps ]);
+// eslint-disable-next-line import/no-unresolved
+import { loadFeatures, autoBindSteps } from 'jest-cucumber';
+import { VendingMachine } from '../../src/vending-machine';
+
+export const vendingMachineSteps = ({ given, and, when, then }) => {
+  let vendingMachine;
+
+  given(/^the vending machine has "(.*)" in stock$/, itemName => {
+    vendingMachine = new VendingMachine();
+    vendingMachine.stockItem(itemName, 1);
+  });
+
+  and('I have inserted the correct amount of money', () => {
+    vendingMachine.insertMoney(0.5);
+  });
+
+  when(/^I purchase "(.*)"$/, itemName => {
+    vendingMachine.dispenseItem(itemName);
+  });
+
+  then(/^my "(.*)" should be dispensed$/, itemName => {
+    const inventoryAmount = vendingMachine.items[itemName];
+    expect(inventoryAmount).toBe(0);
+  });
+};
+
+const features = loadFeatures('./specs/features/auto-binding/**/*.feature');
+
+autoBindSteps(features, [vendingMachineSteps]);

examples/ecmascript/specs/step-definitions/backgrounds.steps.js

@@ -1,72 +1,73 @@
-import { loadFeature, defineFeature } from 'jest-cucumber';
-import { ArcadeMachine, COIN_TYPES } from '../../src/arcade-machine';
-
-const feature = loadFeature('./specs/features/backgrounds.feature');
-
-defineFeature(feature, (test) => {
-    let arcadeMachine;
-
-    beforeEach(() => {
-        arcadeMachine = new ArcadeMachine();
-    });
-
-    const givenMyMachineIsConfiguredToRequireCoins = (given) => {
-        given('my machine is configured to require coins', () => {
-            arcadeMachine.requireCoins = true;
-        });
-    };
-
-    const givenMyMachineIsConfiguredToAcceptUsQuarters = (given) => {
-        given('my machine is configured to accept US Quarters', () => {
-            arcadeMachine.acceptedCoinType = COIN_TYPES.USQuarter;
-        });
-    };
-
-    test('Successfully inserting coins', ({ given, when, then }) => {
-        givenMyMachineIsConfiguredToRequireCoins(given);
-
-        given('I have not inserted any coins', () => {
-            arcadeMachine.balance = 0;
-        });
-
-        when('I insert one US quarter', () => {
-            arcadeMachine.insertCoin(COIN_TYPES.USQuarter);
-        });
-
-        then(/^I should have a balance of (\d+) cents$/, (balance) => {
-            arcadeMachine.balance = balance / 100;
-        });
-    });
-
-    test('Inserting a Canadian coin', ({ given, when, then }) => {
-        let coinStatus;
-
-        givenMyMachineIsConfiguredToRequireCoins(given);
-
-        givenMyMachineIsConfiguredToAcceptUsQuarters(given);
-
-        when('I insert a Canadian Quarter', () => {
-            coinStatus = arcadeMachine.insertCoin(COIN_TYPES.CanadianQuarter);
-        });
-
-        then('my coin should be returned', () => {
-            expect(coinStatus).toBe('CoinReturned');
-        });
-    });
-
-    test('Inserting a badly damaged coin', ({ given, when, then }) => {
-        let coinStatus;
-
-        givenMyMachineIsConfiguredToRequireCoins(given);
-
-        givenMyMachineIsConfiguredToAcceptUsQuarters(given);
-
-        when('I insert a US Quarter that is badly damaged', () => {
-            coinStatus = arcadeMachine.insertCoin(COIN_TYPES.Unknown);
-        });
-
-        then('my coin should be returned', () => {
-            expect(coinStatus).toBe('CoinReturned');
-        });
-    });
-});
+// eslint-disable-next-line import/no-unresolved
+import { loadFeature, defineFeature } from 'jest-cucumber';
+import { ArcadeMachine, COIN_TYPES } from '../../src/arcade-machine';
+
+const feature = loadFeature('./specs/features/backgrounds.feature');
+
+defineFeature(feature, test => {
+  let arcadeMachine;
+
+  beforeEach(() => {
+    arcadeMachine = new ArcadeMachine();
+  });
+
+  const givenMyMachineIsConfiguredToRequireCoins = given => {
+    given('my machine is configured to require coins', () => {
+      arcadeMachine.requireCoins = true;
+    });
+  };
+
+  const givenMyMachineIsConfiguredToAcceptUsQuarters = given => {
+    given('my machine is configured to accept US Quarters', () => {
+      arcadeMachine.acceptedCoinType = COIN_TYPES.USQuarter;
+    });
+  };
+
+  test('Successfully inserting coins', ({ given, when, then }) => {
+    givenMyMachineIsConfiguredToRequireCoins(given);
+
+    given('I have not inserted any coins', () => {
+      arcadeMachine.balance = 0;
+    });
+
+    when('I insert one US quarter', () => {
+      arcadeMachine.insertCoin(COIN_TYPES.USQuarter);
+    });
+
+    then(/^I should have a balance of (\d+) cents$/, balance => {
+      arcadeMachine.balance = balance / 100;
+    });
+  });
+
+  test('Inserting a Canadian coin', ({ given, when, then }) => {
+    let coinStatus;
+
+    givenMyMachineIsConfiguredToRequireCoins(given);
+
+    givenMyMachineIsConfiguredToAcceptUsQuarters(given);
+
+    when('I insert a Canadian Quarter', () => {
+      coinStatus = arcadeMachine.insertCoin(COIN_TYPES.CanadianQuarter);
+    });
+
+    then('my coin should be returned', () => {
+      expect(coinStatus).toBe('CoinReturned');
+    });
+  });
+
+  test('Inserting a badly damaged coin', ({ given, when, then }) => {
+    let coinStatus;
+
+    givenMyMachineIsConfiguredToRequireCoins(given);
+
+    givenMyMachineIsConfiguredToAcceptUsQuarters(given);
+
+    when('I insert a US Quarter that is badly damaged', () => {
+      coinStatus = arcadeMachine.insertCoin(COIN_TYPES.Unknown);
+    });
+
+    then('my coin should be returned', () => {
+      expect(coinStatus).toBe('CoinReturned');
+    });
+  });
+});

examples/ecmascript/specs/step-definitions/basic-scenarios.steps.js

@@ -1,27 +1,28 @@
+// eslint-disable-next-line import/no-unresolved
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { PasswordValidator } from '../../src/password-validator';
 
 const feature = loadFeature('./specs/features/basic-scenarios.feature');
 
-defineFeature(feature, (test) => {
-    let passwordValidator = new PasswordValidator();
-    let accessGranted = false;
+defineFeature(feature, test => {
+  let passwordValidator = new PasswordValidator();
+  let accessGranted = false;
 
-    beforeEach(() => {
-        passwordValidator = new PasswordValidator();
-    });
+  beforeEach(() => {
+    passwordValidator = new PasswordValidator();
+  });
 
-    test('Entering a correct password', ({ given, when, then }) => {
-        given('I have previously created a password', () => {
-            passwordValidator.setPassword('1234');
-        });
+  test('Entering a correct password', ({ given, when, then }) => {
+    given('I have previously created a password', () => {
+      passwordValidator.setPassword('1234');
+    });
 
-        when('I enter my password correctly', () => {
-            accessGranted = passwordValidator.validatePassword('1234');
-        });
+    when('I enter my password correctly', () => {
+      accessGranted = passwordValidator.validatePassword('1234');
+    });
 
-        then('I should be granted access', () => {
-            expect(accessGranted).toBe(true);
-        });
+    then('I should be granted access', () => {
+      expect(accessGranted).toBeTrue();
     });
+  });
 });

examples/ecmascript/specs/step-definitions/more-scenario-outlines.steps.js

@@ -1,9 +1,10 @@
+// eslint-disable-next-line import/no-unresolved
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { SeriesSolver } from '../../src/series-solver';
 
 const feature = loadFeature('./specs/features/more-scenario-outlines.feature');
 
-defineFeature(feature, (test) => {
+defineFeature(feature, test => {
   let solver;
   let solution;
   let terms;
@@ -13,14 +14,14 @@ defineFeature(feature, (test) => {
     solver = new SeriesSolver();
   });
 
-  const whenISolveTheSeries = (when) => {
+  const whenISolveTheSeries = when => {
     when(/^I solve the series$/, () => {
       solution = solver.solve(terms, operator);
     });
   };
 
-  const thenIShouldGetXAsTheAnswer = (then) => {
-    then(/^I should get (.*) as the answer$/, (expectedSolution) => {
+  const thenIShouldGetXAsTheAnswer = then => {
+    then(/^I should get (.*) as the answer$/, expectedSolution => {
       expect(solution).toBe(expectedSolution);
     });
   };
@@ -29,27 +30,26 @@ defineFeature(feature, (test) => {
     given(
       /^I have a series (.*) (.*) (.*) (.*) (.*) (.*) (.*)$/,
       (firstTerm, firstOperator, secondTerm, secondOperator, thirdTerm, thirdOperator, forthTerm) => {
-        expect(firstOperator).toEqual(secondOperator);
-        expect(firstOperator).toEqual(thirdOperator);
+        expect(firstOperator).toStrictEqual(secondOperator);
+        expect(firstOperator).toStrictEqual(thirdOperator);
 
         operator = firstOperator;
         terms = [firstTerm, secondTerm, thirdTerm, forthTerm];
-      });
+      },
+    );
 
     whenISolveTheSeries(when);
 
     thenIShouldGetXAsTheAnswer(then);
   });
 
   test('Adding series', ({ given, when, then }) => {
-    given(
-      /^I add the following series:$/,
-      (table) => {
-        const row = table[0];
-        terms = row.Series.split(` ${row.Operator} `);
-        operator = row.Operator;
-        solver.add(terms, operator, row.Solution);
-      });
+    given(/^I add the following series:$/, table => {
+      const row = table[0];
+      terms = row.Series.split(` ${row.Operator} `);
+      operator = row.Operator;
+      solver.add(terms, operator, row.Solution);
+    });
 
     whenISolveTheSeries(when);
 

examples/ecmascript/specs/step-definitions/scenario-outlines.steps.js

@@ -1,27 +1,28 @@
+// eslint-disable-next-line import/no-unresolved
 import { defineFeature, loadFeature } from 'jest-cucumber';
 import { OnlineSales } from '../../src/online-sales';
 
 const feature = loadFeature('./specs/features/scenario-outlines.feature');
 
 defineFeature(feature, test => {
-    let onlineSales;
-    let salesPrice;
-
-    beforeEach(() => {
-        onlineSales = new OnlineSales();
-    });
+  let onlineSales;
+  let salesPrice;
 
-    test('Selling an <Item> at $<Amount>', ({ given, when, then, pending }) => {
-        given(/^I have a\(n\) (.*)$/, item => {
-            onlineSales.listItem(item);
-        });
+  beforeEach(() => {
+    onlineSales = new OnlineSales();
+  });
 
-        when(/^I sell the (.*)$/, item => {
-            salesPrice = onlineSales.sellItem(item);
-        });
+  test('Selling an <Item> at $<Amount>', ({ given, when, then }) => {
+    given(/^I have a\(n\) (.*)$/, item => {
+      onlineSales.listItem(item);
+    });
 
-        then(/^I should get \$(\d+)$/, expectedSalesPrice => {
-            expect(salesPrice).toBe(parseInt(expectedSalesPrice));
-        });
-    });    
-});
+    when(/^I sell the (.*)$/, item => {
+      salesPrice = onlineSales.sellItem(item);
+    });
+
+    then(/^I should get \$(\d+)$/, expectedSalesPrice => {
+      expect(salesPrice).toBe(parseInt(expectedSalesPrice, 10));
+    });
+  });
+});